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

data/acts-as-taggable-on-mongoid.gemspec

@@ -31,10 +31,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport", "~> 4.2"
-  spec.add_dependency "mongoid", ">= 5.2", "<= 7.0.2"
+  spec.add_dependency "activesupport", ">= 5.0"
+  spec.add_dependency "mongoid", ">= 6.1.1", "<= 7.0.2"
 
-  spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "codecov", "~> 0.1", "~> 0.1.0"
   spec.add_development_dependency "cornucopia"
   spec.add_development_dependency "database_cleaner"
@@ -45,7 +44,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pronto-rails_best_practices"
   spec.add_development_dependency "pronto-reek"
   spec.add_development_dependency "pronto-rubocop"
-  spec.add_development_dependency "rake", "~> 12.3"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec_junit_formatter", "~> 0.4.1"
   spec.add_development_dependency "rubocop"

data/lib/acts-as-taggable-on-mongoid.rb

@@ -11,11 +11,13 @@ module ActsAsTaggableOnMongoid
   eager_autoload do
     autoload :Configuration
     autoload :TagList
+    autoload :TaggerTagList
     autoload :GenericParser
     autoload :DefaultParser
     # autoload :TagsHelper
 
     autoload_under "taggable/tag_type_definition" do
+      autoload :ListMethods
       autoload :Attributes
       autoload "Changeable"
       autoload :Names
@@ -42,11 +44,16 @@ module ActsAsTaggableOnMongoid
       autoload :ListTags
       autoload :TaggedWith
       autoload :TaggedWithQuery
-      #   autoload :Ownership
+      autoload :TaggerRelation
       #   autoload :Related
     end
 
+    autoload_under :Tagger do
+      autoload "TagMethods"
+    end
+
     autoload :Taggable
+    autoload :Tagger
 
     autoload_under "models/concerns" do
       autoload :TagFields
@@ -67,7 +74,6 @@ module ActsAsTaggableOnMongoid
     autoload_under :Models do
       autoload :Tag
       autoload :Tagging
-      # autoload :Tagger
     end
 
     autoload_under :Errors do
@@ -102,5 +108,5 @@ end
 
 ::ActiveSupport.on_load(:mongoid) do
   include ActsAsTaggableOnMongoid::Taggable
-  # include ActsAsTaggableOn::Tagger
+  include ActsAsTaggableOnMongoid::Tagger
 end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tag_associations.rb

@@ -10,6 +10,18 @@ module ActsAsTaggableOnMongoid
           ### ASSOCIATIONS:
 
           has_many :taggings, dependent: :destroy, class_name: "ActsAsTaggableOnMongoid::Models::Tagging"
+          belongs_to :owner, polymorphic: true, optional: true, index: true
+
+          after_save :atom_unset_blank_owner
+        end
+
+        private
+
+        def atom_unset_blank_owner
+          return if !attributes.key?("owner_id") && !attributes.key?("owner_type")
+          return if owner_id.present? && owner_type.present?
+
+          unset(:owner_id, :owner_type)
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tag_fields.rb

@@ -17,7 +17,10 @@ module ActsAsTaggableOnMongoid
 
           # field :type, type: String
 
-          index({ name: 1, taggable_type: 1, context: 1 }, unique: true)
+          index({ name: 1, context: 1, taggable_type: 1, owner_id: 1, owner_type: 1 },
+                unique: true,
+                name:   "name_taggable_type_context_owner")
+          index(owner_id: 1, owner_type: 1)
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tag_methods.rb

@@ -10,7 +10,13 @@ module ActsAsTaggableOnMongoid
 
         # rubocop:disable Metrics/BlockLength
         class_methods do
-          def find_or_create_all_with_like_by_name(tag_definition, *list)
+          def find_or_create_tagger_list_with_like_by_name(tag_definition, tagger_list)
+            tagger_list.each_with_object([]) do |(tagger, tag_list), array|
+              array.concat find_or_create_all_with_like_by_name_owner tag_definition, tagger, tag_list
+            end
+          end
+
+          def find_or_create_all_with_like_by_name_owner(tag_definition, owner, *list)
             list = ActsAsTaggableOnMongoid::TagList.new(tag_definition, *Array.wrap(list).flatten)
 
             return [] if list.empty?
@@ -19,9 +25,7 @@ module ActsAsTaggableOnMongoid
               begin
                 tries ||= 3
 
-                existing_tag = tag_definition.tags_table.for_tag(tag_definition).named(tag_name).first
-
-                existing_tag || create_tag(tag_definition, tag_name)
+                find_or_create_tag(tag_name, tag_definition, owner)
               rescue Mongoid::Errors::Validations
                 # :nocov:
                 if (tries -= 1).positive?
@@ -34,21 +38,26 @@ module ActsAsTaggableOnMongoid
             end
           end
 
-          def create_tag(tag_definition, name)
+          # :reek:UtilityFunction
+          def create_tag(tag_definition, owner, name)
             tag_definition.tags_table.create!(name:          name,
+                                              owner:         owner,
                                               context:       tag_definition.tag_type,
                                               taggable_type: tag_definition.owner.name)
           end
 
           def as_8bit_ascii(string)
             string = string.to_s
-            if defined?(Encoding)
-              string.dup.force_encoding("BINARY")
-            else
-              # :nocov:
-              string.mb_chars
-              # :nocov:
-            end
+
+            string.mb_chars
+          end
+
+          private
+
+          def find_or_create_tag(tag_name, tag_definition, owner)
+            existing_tag = tag_definition.tags_table.for_tag(tag_definition).named(tag_name).owned_by(owner).first
+
+            existing_tag || create_tag(tag_definition, owner, tag_name)
           end
         end
 

data/lib/acts_as_taggable_on_mongoid/models/concerns/tag_migration.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Models
+    module Concerns
+      # A module that defines methods to migrate a Tag model.
+      #
+      # Mongoid does not have a standardized migration scheme, but migrations of one kind or another
+      # are often a fact of life, and are in this situation because of the need to change an existing
+      # index.
+      #
+      # Using whatever migration methodology you prefer, you need to run the appropriate migration method
+      # or methods on the Tag module used by your project.
+      #
+      # The migrations are named for the ActsAsTaggableMongoid versions upon which they need to be run.
+      # Run the correct migration(s) for the version of ActsAsTaggableOnMongoid you are currently using
+      # This module does not and cannot verify the version you are migrating from nor if the migration
+      # has been run before.  Doing so is assumed to be the responsibility of your chosen
+      # Migration methodology.
+      #
+      # Example:
+      #
+      # # When a migration is needed, the method "up" is called:
+      # def up
+      #   TagModel.include ActsAsTaggableOnMongoid::Models::Concerns::TagMigration
+      #   TagModel.atom_migrate_up_6_0_1_to_6_1_1
+      # end
+      #
+      # The migration methods should only be run once if possible, but every reasonable effort is made to
+      # ensure that the migration methods are safe to re-run.
+      module TagMigration
+        extend ActiveSupport::Concern
+
+        class_methods do
+          # :reek:UncommunicativeMethodName - The name indicates what gem versions the migration is from/to
+          def atom_migrate_up_6_0_1_to_6_1_1
+            indexes = collection.indexes
+            indexes.drop_one "name_1_taggable_type_1_context_1" if indexes.get "name_1_taggable_type_1_context_1"
+
+            create_indexes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tag_scopes.rb

@@ -15,9 +15,10 @@ module ActsAsTaggableOnMongoid
           scope :named_any, ->(*names) { where(:name.in => names.map { |name| as_8bit_ascii(name) }) }
           scope :named_like, ->(name) { where(name: /#{as_8bit_ascii(name)}/i) }
           scope :named_like_any, ->(*names) { where(:name.in => names.map { |name| /#{as_8bit_ascii(name)}/i }) }
-          scope :for_context, ->(context) { where(context: context) }
+          scope :owned_by, ->(owner) { owner ? where(owner: owner) : where(:owner_id.exists => false) }
+          scope :for_tag_type, ->(context) { where(context: context) }
           scope :for_taggable_class, ->(taggable_type) { where(taggable_type: taggable_type.name) }
-          scope :for_tag, ->(tag_definition) { for_taggable_class(tag_definition.owner).for_context(tag_definition.tag_type) }
+          scope :for_tag, ->(tag_definition) { for_taggable_class(tag_definition.owner).for_tag_type(tag_definition.tag_type) }
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tag_validations.rb

@@ -12,7 +12,7 @@ module ActsAsTaggableOnMongoid
           validates :name, presence: true
           validates :context, presence: true
           validates :taggable_type, presence: true
-          validates :name, uniqueness: { scope: %i[context taggable_type] }
+          validates :name, uniqueness: { scope: %i[context taggable_type owner] }
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_associations.rb

@@ -7,9 +7,21 @@ module ActsAsTaggableOnMongoid
         extend ActiveSupport::Concern
 
         included do
+          ### ASSOCIATIONS:
+
           belongs_to :tag, counter_cache: true, inverse_of: :taggings
+          belongs_to :tagger, polymorphic: true, optional: true
           belongs_to :taggable, polymorphic: true
-          # belongs_to :tagger, { polymorphic: true, optional: true }
+
+          before_validation :atom_unset_blank_owner
+        end
+
+        private
+
+        def atom_unset_blank_owner
+          return if tagger_id.present? && tagger_type.present?
+
+          unset(:tagger_id, :tagger_type)
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_fields.rb

@@ -13,10 +13,12 @@ module ActsAsTaggableOnMongoid
           field :tag_name, type: String
           field :context, type: String
 
-          # If/when adding the concept of a tagger, this index will need to be changed.
-          index({ taggable_id: 1, taggable_type: 1, context: 1, tag_name: 1 }, unique: true, name: "tagging_taggable_context_tag_name")
+          index({ taggable_id: 1, taggable_type: 1, context: 1, tagger_id: 1, tagger_type: 1, tag_name: 1 },
+                unique: true,
+                name:   "tagging_taggable_tagger_context_tag_name")
           index(tag_name: 1)
           index(tag_id: 1, tag_type: 1)
+          index(tagger_id: 1, tagger_type: 1)
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_methods.rb

@@ -32,7 +32,7 @@ module ActsAsTaggableOnMongoid
 
           return unless tag_definition
 
-          tag_list = taggable.public_send(tag_definition.tag_list_name)
+          tag_list = taggable.public_send(tag_definition.tagger_tag_lists_name)[tagger]
           tag_list.add_tagging(self)
         end
 
@@ -45,7 +45,7 @@ module ActsAsTaggableOnMongoid
 
           return unless tag_definition
 
-          taggable_was.public_send(tag_definition.tag_list_name).remove(tag_name_was)
+          taggable_was.public_send(tag_definition.tagger_tag_lists_name)[tagger].remove(tag_name_was)
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_migration.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Models
+    module Concerns
+      # A module that defines methods to migrate a Tag model.
+      #
+      # Mongoid does not have a standardized migration scheme, but migrations of one kind or another
+      # are often a fact of life, and are in this situation because of the need to change an existing
+      # index.
+      #
+      # Using whatever migration methodology you prefer, you need to run the appropriate migration method
+      # or methods on the Tag module used by your project.
+      #
+      # The migrations are named for the ActsAsTaggableMongoid versions upon which they need to be run.
+      # Run the correct migration(s) for the version of ActsAsTaggableOnMongoid you are currently using
+      # This module does not and cannot verify the version you are migrating from nor if the migration
+      # has been run before.  Doing so is assumed to be the responsibility of your chosen
+      # Migration methodology.
+      #
+      # Example:
+      #
+      # # When a migration is needed, the method "up" is called:
+      # def up
+      #   TaggingModel.include ActsAsTaggableOnMongoid::Models::Concerns::TaggingMigration
+      #   TaggingModel.atom_migrate_up_6_0_1_to_6_1_1
+      # end
+      #
+      # The migration methods should only be run once if possible, but every reasonable effort is made to
+      # ensure that the migration methods are safe to re-run.
+      module TaggingMigration
+        extend ActiveSupport::Concern
+
+        class_methods do
+          # :reek:UncommunicativeMethodName - The name indicates what gem versions the migration is from/to
+          def atom_migrate_up_6_0_1_to_6_1_1
+            indexes = collection.indexes
+            indexes.drop_one "tagging_taggable_context_tag_name" if indexes.get "tagging_taggable_context_tag_name"
+
+            create_indexes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_scopes.rb

@@ -10,12 +10,14 @@ module ActsAsTaggableOnMongoid
         DEFAULT_CONTEXT = "tags"
 
         included do
-          # scope :owned_by, ->(owner) { where(tagger: owner) }
-          # scope :not_owned, -> { where(tagger_id: nil, tagger_type: nil) }
+          # aliased scopes from ActsAsTaggable
+          scope :owned_by, ->(tagger) { tagged_by(tagger) }
+          scope :not_owned, -> { tagged_by(nil) }
 
-          scope :by_contexts, ->(*contexts) { where(:context.in => Array.wrap(contexts.presence || DEFAULT_CONTEXT)) }
-          scope :by_context, ->(context = DEFAULT_CONTEXT) { by_contexts(context.to_s) }
-          scope :for_tag, ->(tag_definition) { where(taggable_type: tag_definition.owner.name).by_context(tag_definition.tag_type) }
+          scope :by_tag_types, ->(*tag_types) { where(:context.in => Array.wrap(tag_types.presence || DEFAULT_CONTEXT)) }
+          scope :by_tag_type, ->(tag_type = DEFAULT_CONTEXT) { by_tag_types(tag_type.to_s) }
+          scope :tagged_by, ->(tagger) { tagger ? where(tagger: tagger) : where(:tagger_id.exists => false) }
+          scope :for_tag, ->(tag_definition) { where(taggable_type: tag_definition.owner.name).by_tag_type(tag_definition.tag_type) }
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_validations.rb

@@ -10,13 +10,9 @@ module ActsAsTaggableOnMongoid
         included do
           validates :tag_name, presence: true
           validates :context, presence: true
-          validates :tag, presence: true
-          validates :taggable, presence: true
 
-          # validates :tag_id, uniqueness: {scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]}
-          validates :tag_name, uniqueness: { scope: %i[taggable_type taggable_id context] }
-          # validates :tag_id, uniqueness: {scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]}
-          validates :tag_id, uniqueness: { scope: %i[taggable_type taggable_id context] }
+          validates :tag_name, uniqueness: { scope: %i[taggable_id taggable_type context tagger_id tagger_type] }
+          validates :tag_id, uniqueness: { scope: %i[taggable_id taggable_type context tagger_id tagger_type] }
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/tag_list.rb

@@ -12,6 +12,16 @@ module ActsAsTaggableOnMongoid
   #
   # If the input value(s) are to be parsed, then all values passed in are parsed.
   #
+  # Options:
+  #   parse   - True/False - indicates if all of the strings that are passed in are to be parsed
+  #             to split them into an array of strings.
+  #             Please note - if the passed in value is an array of strings, every string in the array
+  #             will be parsed.  If it is a single array, then just that string is parsed.
+  #   parser  - Class - A class that is used to parse the passed in strings.
+  #             If this parameter is supplied, parse is assumed to be truthy even if it is not passed in.
+  #   tagger  - object - An object that is to be used as the Tagger for the Taggable object.
+  #             This parameter is ignored if the tag does not support Taggers.
+  #
   # Examples:
   #   TagList.new(tag_definition, "value 1", "value 2")
   #   # > TagList<> ["value 1", "value 2"]
@@ -38,6 +48,40 @@ module ActsAsTaggableOnMongoid
       add(*args)
     end
 
+    class << self
+      def new_taggable_list(tag_definition, taggable)
+        list = ActsAsTaggableOnMongoid::TagList.new(tag_definition)
+
+        list.taggable = taggable
+
+        list
+      end
+    end
+
+    def dup
+      list          = ActsAsTaggableOnMongoid::TagList.new(tag_definition, *self)
+      list.tagger   = instance_variable_get(:@tagger) if instance_variable_defined?(:@tagger)
+      list.taggable = taggable
+
+      list
+    end
+
+    def tagger=(value)
+      return unless tag_definition.tagger?
+
+      instance_variable_set(:@tagger, value)
+    end
+
+    def tagger
+      return nil unless tag_definition.tagger?
+      return tag_definition.default_tagger(taggable) unless instance_variable_defined?(:@tagger)
+
+      tagger = instance_variable_get(:@tagger)
+      tagger = taggable&.public_send(tagger) if tagger.is_a?(Symbol)
+
+      instance_variable_set(:@tagger, tagger)
+    end
+
     ##
     # Add tags to the tag_list. Duplicate or blank tags will be ignored.
     # Use the <tt>:parse</tt> option to add an unparsed tag string.
@@ -53,6 +97,17 @@ module ActsAsTaggableOnMongoid
       self
     end
 
+    ##
+    # Replaces the tags with the tags passed in.
+    #
+    # Example:
+    #   tag_list.set("Fun", "Happy")
+    #   tag_list.set("Fun, Happy", :parse => true)
+    def set(*names)
+      clear
+      add(*names)
+    end
+
     # Append---Add the tag to the tag_list. This
     # expression returns the tag_list itself, so several appends
     # may be chained together.
@@ -63,7 +118,13 @@ module ActsAsTaggableOnMongoid
     # Concatenation --- Returns a new tag list built by concatenating the
     # two tag lists together to produce a third tag list.
     def +(other)
-      TagList.new(tag_definition).add(*self).add(other)
+      dup.add(other)
+    end
+
+    # Removal --- Returns a new tag list built by removing the
+    # passed in tag list to produce a third tag list.
+    def -(other)
+      dup.remove(other)
     end
 
     # Appends the elements of +other_tag_list+ to +self+.
@@ -75,6 +136,27 @@ module ActsAsTaggableOnMongoid
       self
     end
 
+    # Appends the elements of +other_tag_list+ to +self+.
+    def clear
+      notify_will_change
+
+      super
+
+      self
+    end
+
+    # Appends the elements of +other_tag_list+ to +self+.
+    def silent_concat(other_tag_list)
+      temp_taggable = taggable
+      self.taggable = nil
+
+      concat(other_tag_list)
+
+      self.taggable = temp_taggable
+
+      self
+    end
+
     ##
     # Remove specific tags from the tag_list.
     # Use the <tt>:parse</tt> option to add an unparsed tag string.
@@ -151,13 +233,18 @@ module ActsAsTaggableOnMongoid
       self
     end
 
-    # :reek:FeatureEnvy
-    # :reek:DuplicateMethodCall
     def extract_and_apply_options!(args)
       dup_args = args.dup
       options  = dup_args.extract_options!.dup
-      options.assert_valid_keys :parse, :parser
 
+      options.assert_valid_keys :parse, :parser, :tagger
+
+      instance_variable_set(:@tagger, options[:tagger]) if options.key?(:tagger) && tag_definition.tagger?
+
+      parse_args_values(dup_args, options)
+    end
+
+    def parse_args_values(dup_args, options)
       options_parser = options[:parser]
       run_parser     = options_parser || tag_definition.parser