acts-as-taggable-on-mongoid 6.0.1.4 → 6.1.1.11

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

@@ -10,6 +10,18 @@ module ActsAsTaggableOnMongoid
           @tag_list_name ||= "#{single_tag_type}_list"
         end
 
+        def from_list_name
+          @from_list_name ||= "#{tag_type.to_s.pluralize}_from"
+        end
+
+        def tagger_tag_list_name
+          @tagger_tag_list_name ||= "tagger_#{single_tag_type}_list"
+        end
+
+        def tagger_tag_lists_name
+          @tagger_tag_lists_name ||= "tagger_#{single_tag_type}_lists"
+        end
+
         def tag_list_variable_name
           @tag_list_variable_name ||= "@#{tag_list_name}"
         end

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/all_tags_query.rb

@@ -10,7 +10,7 @@ module ActsAsTaggableOnMongoid
         end
 
         def included_ids
-          selector         = Origin::Selector.new
+          selector         = Mongoid::Criteria::Queryable::Selector.new
           selector[:count] = tag_list.count
 
           build_ids_from(selector)

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/any_tags_query.rb

@@ -10,7 +10,7 @@ module ActsAsTaggableOnMongoid
         end
 
         def included_ids
-          selector         = Origin::Selector.new
+          selector         = Mongoid::Criteria::Queryable::Selector.new
           selector[:count] = { "$gt" => 0 }
 
           build_ids_from(selector)

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/exclude_tags_query.rb

@@ -10,7 +10,7 @@ module ActsAsTaggableOnMongoid
         end
 
         def included_ids
-          selector         = Origin::Selector.new
+          selector         = Mongoid::Criteria::Queryable::Selector.new
           selector[:count] = { "$gt" => 0 }
 
           ids = build_ids_from(selector)

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/match_all_tags_query.rb

@@ -10,7 +10,7 @@ module ActsAsTaggableOnMongoid
         end
 
         def included_ids
-          selector         = Origin::Selector.new
+          selector         = Mongoid::Criteria::Queryable::Selector.new
           selector[:count] = { "$ne" => tag_list.count }
 
           AllTagsQuery.new(tag_definition, tag_list, options).included_ids -

data/lib/acts_as_taggable_on_mongoid/taggable/tagger_relation.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    # Overides of methods from Mongoid::Processing which process attributes for methods like
+    # `assign_attributes`, `create`, `new`, and `update_attributes`
+    #
+    # The need for this override is because the base method splits the order that methods are
+    # processed in to process relationships after processing other attributes.
+    #
+    # However, tag lists may rely upon values set in relationships - forcing us to process
+    # tag lists AFTER relationships have been processed - preventing the need to order attributes
+    # (which wouldn't help anyway because of the way process_attributes works.)
+    #
+    # ONLY taggings that have a default and which accept tagger values and which default the
+    # tagger based on the taggable object could be affected by other attributes set at the same time
+    # as the tag list.  Thus only those tag values are delayed until after all other attributes are set.
+    module TaggerRelation
+      def process_attributes(attrs = nil)
+        update_attrs, defaulted_attrs = atom_attributes_without_defaults(attrs)
+
+        super(update_attrs)
+
+        defaulted_attrs.each do |key, value|
+          public_send("#{key}=", value)
+        end
+      end
+
+      private
+
+      def atom_attributes_without_defaults(attrs)
+        return_attributes    = {}
+        defaulted_attributes = {}
+
+        sanitize_for_mass_assignment(attrs)&.each do |key, value|
+          tag_def = atom_tag_definition_from_type(key)
+
+          if tag_def&.tag_list_uses_default_tagger?
+            defaulted_attributes[key] = value
+          else
+            return_attributes[key] = value
+          end
+        end
+
+        [return_attributes, defaulted_attributes]
+      end
+
+      def atom_tag_definition_from_type(key)
+        tag_types.detect { |_type, tag_definition| tag_definition.tag_list_name == key.to_s }&.last
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/utils/tag_list_diff.rb

@@ -18,7 +18,7 @@ module ActsAsTaggableOnMongoid
         def initialize(tag_definition:, tags:, current_tags:)
           @tag_definition = tag_definition
           @tags           = tags
-          @current_tags   = current_tags
+          @current_tags   = current_tags.map(&:tag).compact
 
           @old_tags = {}
           @new_tags = {}
@@ -35,7 +35,7 @@ module ActsAsTaggableOnMongoid
           new_tags.each do |tag|
             tagging = taggable.
                 public_send(tag_definition.taggings_name).
-                new(tag_name: tag.name, context: tag_definition.tag_type, taggable: taggable, tag: tag)
+                new(tag_name: tag.name, context: tag_definition.tag_type, taggable: taggable, tag: tag, tagger: tag.owner)
 
             next if tagging.save
             next if ignore_tagging_error(tagging)
@@ -50,8 +50,8 @@ module ActsAsTaggableOnMongoid
 
           taggable.
               public_send(tag_definition.taggings_name).
-              by_context(tag_definition.tag_type).
-              where(:tag_name.in => old_tags.map(&:name)).
+              by_tag_type(tag_definition.tag_type).
+              where(:tag_id.in => old_tags.map(&:id)).
               destroy_all
         end
 
@@ -94,14 +94,16 @@ module ActsAsTaggableOnMongoid
 
         # :reek:NestedIterators
         def preserve_new_tag_list_order
-          preserved_tags = new_tags | current_tags[first_ordered_difference..-1] & shared_tags
-
           # Order the array of tag objects to match the tag list
           @new_tags = tags.map do |tag|
-            preserved_tags.find { |preserved_tag| preserved_tag.name == tag.name }
+            preserved_tags.detect { |preserved_tag| preserved_tag.name == tag.name && preserved_tag.owner == tag.owner }
           end.compact
         end
 
+        def preserved_tags
+          @preserved_tags ||= new_tags | current_tags[first_ordered_difference..-1] & shared_tags
+        end
+
         def first_ordered_difference
           return @first_ordered_difference if defined?(@first_ordered_difference)
 

data/lib/acts_as_taggable_on_mongoid/tagger.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  # This module defines the class methods to be added to the Mongoid model so that
+  # tags can be defined on and added to a model.
+  #
+  # When a tag is added to a model, additional modules will be included to add methods that
+  # are needed only if a tag is actually being used.
+  module Tagger
+    extend ActiveSupport::Concern
+
+    # rubocop:disable Metrics/BlockLength
+
+    class_methods do
+      # Options include:
+      #   * tags_table
+      #     The class to use for Tags
+      #   * taggings_table
+      #     The class to use for Taggings
+
+      # Make a model a tagger.  This allows a model to claim ownership of taggings and their tags.
+      #
+      # Example:
+      #   class User
+      #     acts_as_tagger
+      #   end
+      def acts_as_tagger(options = {})
+        options = options.with_indifferent_access
+
+        add_taggings_tagger_relation(options)
+        add_tags_owner_relation(options)
+
+        include ActsAsTaggableOnMongoid::Tagger::TagMethods
+      end
+
+      private
+
+      def add_tags_owner_relation(options)
+        tags_table = options[:tags_table] || ActsAsTaggableOnMongoid.tags_table
+        table_name = tags_table.name
+        tags_name  = "owned_#{table_name.demodulize.underscore.downcase.pluralize.to_sym}"
+
+        return if relations[tags_name.to_s]
+
+        has_many tags_name,
+                 as:         :owner,
+                 dependent:  :destroy,
+                 class_name: table_name
+      end
+
+      def add_taggings_tagger_relation(options)
+        taggings_table = options[:taggings_table] || ActsAsTaggableOnMongoid.taggings_table
+        table_name     = taggings_table.name
+        taggings_name  = "owned_#{table_name.demodulize.underscore.downcase.pluralize.to_sym}"
+
+        return if relations[taggings_name.to_s]
+
+        has_many taggings_name,
+                 as:         :tagger,
+                 dependent:  :destroy,
+                 class_name: table_name
+      end
+    end
+
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/acts_as_taggable_on_mongoid/tagger/tag_methods.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Tagger
+    # A module defining Tagger methods allowing the Tagger object to tag Taggable objects
+    #
+    # This module is dynamically added to a model when the model calls acts_as_tagger
+
+    # :reek:DataClump
+    module TagMethods
+      ##
+      # Taggs the passed in taggable object with the tag values passed in to it.
+      #
+      # Parameters:
+      #   taggable        - the object to tag
+      #   non-hash values - the values to use to tag taggable with
+      #   {options}
+      #     with:         - Alternative to non-hash values.  If found as an option it will replace
+      #                     any non-hash values.  If not specified, any tags for this tagger will be
+      #                     removed from taggable
+      #     on:           - the tag list within taggable to be set.  This will default to `:tag`
+      #     parse:        - Boolean indicating if the tags should be parsed.  This will default to "true"
+      #     parser:       - Class to be used to parse the values.
+      #     skip_save:    - Do not save the taggable object with the new tagging.
+      def tag(taggable, *args)
+        options = atom_tag(taggable, *args)
+
+        taggable.save unless options[:skip_save]
+      end
+
+      ##
+      # tag, but uses `save!` instead of `save` to save the taggable model.
+      def tag!(taggable, *args)
+        options = atom_tag(taggable, *args)
+
+        taggable.save! unless options[:skip_save]
+      end
+
+      def self.atom_extract_tag_options(set_list)
+        options = set_list.extract_options!
+
+        options.assert_valid_keys :with,
+                                  :on,
+                                  :replace,
+                                  :parse,
+                                  :parser,
+                                  :skip_save
+
+        options[:parse] = options.fetch(:parse) { true } || options.key?(:parser)
+
+        options
+      end
+
+      private
+
+      # :reek:FeatureEnvy
+      def atom_tag(taggable, *args)
+        set_list = args.dup
+        options  = ActsAsTaggableOnMongoid::Tagger::TagMethods.atom_extract_tag_options(set_list)
+        set_list = Array.wrap(options[:with]) if options.key?(:with)
+
+        tag_list     = taggable.public_send("tagger_#{options.fetch(:on) { :tag }}_list", self)
+        list_options = options.slice(:parse, :parser)
+        if options[:replace]
+          tag_list.set(*set_list, list_options)
+        else
+          tag_list.add(*set_list, list_options)
+        end
+
+        options
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/tagger_tag_list.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  # A hash like collection of tag lists grouped by tagger
+
+  # :reek:RepeatedConditional
+  class TaggerTagList
+    include Comparable
+
+    delegate :keys,
+             :values,
+             :length,
+             :delete,
+             :clear,
+             :each,
+             :each_with_object,
+             :detect,
+             :reject!,
+             :any?,
+             :each_value,
+             :map,
+             to: :tagger_tag_lists
+
+    attr_reader :taggable,
+                :tag_definition
+
+    def initialize(tag_definition, taggable)
+      @tag_definition = tag_definition
+      @taggable       = taggable
+
+      @tagger_tag_lists = Hash.new { ActsAsTaggableOnMongoid::TagList.new_taggable_list(tag_definition, taggable) }
+    end
+
+    def compact!
+      reject! { |_key, value| value.blank? }
+      self
+    end
+
+    def compact
+      dup.compact!
+    end
+
+    def flatten
+      list = ActsAsTaggableOnMongoid::TagList.new_taggable_list(tag_definition, taggable)
+
+      each_value do |tag_list|
+        list.concat(tag_list)
+      end
+
+      list
+    end
+
+    def <=>(other)
+      compact!
+
+      if other.is_a?(ActsAsTaggableOnMongoid::TagList)
+        compare_to_tag_list(other)
+      elsif other.is_a?(ActsAsTaggableOnMongoid::TaggerTagList)
+        other.compact!
+
+        compare_to_tagger_tag_list(other)
+      else
+        super(other)
+      end
+    end
+
+    def [](tagger)
+      list = tagger_tag_lists[tagger]
+
+      list.tagger = tagger
+
+      tagger_tag_lists[tagger] = list
+    end
+
+    def []=(tagger, value)
+      tagger_list = self[tagger]
+
+      if value.is_a?(ActsAsTaggableOnMongoid::TagList)
+        tagger_list.set(value)
+      else
+        value           = Array.wrap(value).dup
+        options         = value.extract_options!
+        options[:parse] = options.fetch(:parse) { true }
+
+        value = [*value, options]
+
+        tagger_list.set(*value)
+      end
+    end
+
+    def dup
+      list = ActsAsTaggableOnMongoid::TaggerTagList.new(tag_definition, taggable)
+
+      each do |tagger, tag_list|
+        list[tagger].silent_concat(tag_list) if tag_list.present?
+      end
+
+      list
+    end
+
+    def taggable=(value)
+      @taggable = value
+
+      tagger_tag_lists.each_value do |tag_list|
+        tag_list.taggable = taggable
+      end
+    end
+
+    def notify_will_change
+      return unless taggable
+
+      taggable.tag_list_on_changed tag_definition
+    end
+
+    def blank?
+      tagger_tag_lists.values.all?(&:blank?)
+    end
+
+    private
+
+    attr_reader :tagger_tag_lists
+
+    def compare_tagger_tag_list_properties(other)
+      sub_compare = keys.length <=> other.keys.length
+      return sub_compare unless sub_compare&.zero?
+
+      taggable <=> other.taggable
+    end
+
+    def compare_to_tagger_tag_list(other)
+      sub_compare = compare_tagger_tag_list_properties(other)
+      return sub_compare unless sub_compare&.zero?
+
+      any? do |key, tag_list|
+        other_tag_list = other[key]
+
+        sub_compare = if tag_definition.preserve_tag_order
+                        tag_list <=> other_tag_list
+                      else
+                        tag_list.sort <=> other_tag_list.sort
+                      end
+
+        !sub_compare&.zero?
+      end
+
+      sub_compare
+    end
+
+    def compare_tag_list_properties(other)
+      sub_compare = tagger_tag_lists.length <=> 1
+      return sub_compare unless sub_compare&.zero?
+
+      sub_compare = keys.first <=> other.tagger
+      return sub_compare unless sub_compare&.zero?
+
+      taggable <=> other.taggable
+    end
+
+    def compare_to_tag_list(other)
+      sub_compare = compare_tag_list_properties(other)
+      return sub_compare unless sub_compare&.zero?
+
+      tagger_list = values.first
+      if tag_definition.preserve_tag_order
+        tagger_list <=> other
+      else
+        tagger_list.sort <=> other.sort
+      end
+    end
+  end
+end