acts-as-taggable-on-mongoid 6.0.1.1

data/lib/acts_as_taggable_on_mongoid/models/tag.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Models
+    # A class representing all tags that have ever been set on a model.
+    class Tag
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      field :name, type: String
+      field :taggings_count, type: Integer, default: 0
+      field :context, type: String
+      field :taggable_type, type: String
+
+      # field :type, type: String
+
+      index({ name: 1, taggable_type: 1, context: 1 }, unique: true)
+
+      ### ASSOCIATIONS:
+
+      has_many :taggings, dependent: :destroy, class_name: "ActsAsTaggableOnMongoid::Models::Tagging"
+
+      ### VALIDATIONS:
+
+      validates :name, presence: true
+      validates :context, presence: true
+      validates :taggable_type, presence: true
+      validates :name, uniqueness: { scope: %i[context taggable_type] }
+
+      ### SCOPES:
+      scope :most_used, ->(limit = 20) { order("taggings_count desc").limit(limit) }
+      scope :least_used, ->(limit = 20) { order("taggings_count asc").limit(limit) }
+
+      scope :named, ->(name) { where(name: as_8bit_ascii(name)) }
+      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 :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) }
+
+      ### CLASS METHODS:
+
+      class << self
+        def find_or_create_all_with_like_by_name(tag_definition, *list)
+          list = ActsAsTaggableOnMongoid::TagList.new(tag_definition, *Array.wrap(list).flatten)
+
+          return [] if list.empty?
+
+          list.map do |tag_name|
+            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)
+            rescue Mongoid::Errors::Validations
+              # :nocov:
+              if (tries -= 1).positive?
+                retry
+              end
+
+              raise ActsAsTaggableOnMongoid::Errors::DuplicateTagError.new, "'#{tag_name}' has already been taken"
+              # :nocov:
+            end
+          end
+        end
+
+        private
+
+        def create_tag(tag_definition, name)
+          tag_definition.tags_table.create(name:          name,
+                                           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
+        end
+      end
+
+      ### INSTANCE METHODS:
+
+      def ==(other)
+        super || (other.class == self.class &&
+            name == other.name &&
+            context == other.context &&
+            taggable_type == other.taggable_type)
+      end
+
+      def to_s
+        name
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/models/tagging.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Models
+    # A class representing the actual tags assigned to a particular model object
+    class Tagging
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      DEFAULT_CONTEXT = "tags"
+
+      after_save :tagging_saved
+      after_destroy :tagging_destroyed
+
+      field :tag_name, type: String
+      field :context, type: String
+
+      belongs_to :tag, counter_cache: true, inverse_of: :taggings
+      belongs_to :taggable, polymorphic: true
+      # belongs_to :tagger, { polymorphic: true, optional: true }
+
+      # 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(tag_name: 1)
+      index(tag_id: 1, tag_type: 1)
+
+      # scope :owned_by, ->(owner) { where(tagger: owner) }
+      # scope :not_owned, -> { where(tagger_id: nil, tagger_type: 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) }
+
+      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] }
+
+      after_destroy :remove_unused_tags
+
+      private
+
+      def remove_unused_tags
+        return nil unless taggable
+
+        tag_definition = taggable.tag_types[context]
+
+        return unless tag_definition&.remove_unused_tags?
+
+        tag.destroy if tag.reload.taggings_count.zero?
+      end
+
+      def tagging_saved
+        tag_definition = taggable.tag_types[context]
+
+        return unless tag_definition
+
+        tag_list = taggable.public_send(tag_definition.tag_list_name)
+        tag_list.add_tagging(self)
+      end
+
+      def tagging_destroyed
+        taggable_was = taggable_type_was.constantize.where(id: taggable_id_was).first
+
+        return unless taggable_was
+
+        tag_definition = taggable_was.tag_types[context_was]
+
+        return unless tag_definition
+
+        taggable_was.public_send(tag_definition.tag_list_name).remove(tag_name_was)
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/tag_list.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# require "active_support/core_ext/module/delegation"
+
+module ActsAsTaggableOnMongoid
+  # A list of tags.  The TagList must be initialized with a tag definition so that it knows how to clean
+  # the list properly and to convert the list to a string.
+  #
+  # All methods that add objects to the list (initialization, concat, etc.) optionally take an array of values including
+  # options to parse the values and to optionally specifiy the parser to use.  If no parser is specified, then
+  # parser for the tag_definition is used.
+  #
+  # If the input value(s) are to be parsed, then all values passed in are parsed.
+  #
+  # Examples:
+  #   TagList.new(tag_definition, "value 1", "value 2")
+  #   # > TagList<> ["value 1", "value 2"]
+  #
+  #   TagList.new(tag_definition, "value 1, value 2", parse: true)
+  #   # > TagList<> ["value 1", "value 2"]
+  #
+  #   TagList.new(tag_definition, "value 1, value 2", "value 3, value 4", parse: true)
+  #   # > TagList<> ["value 1", "value 2", "value 3", "value 4"]
+  #
+  #   TagList.new(tag_definition, "value 1, value 2", "value 3, value 4", parser: ActsAsTaggableOnMongoid::GenericParser)
+  #   # > TagList<> ["value 1", "value 2", "value 3", "value 4"]
+
+  # :reek:MissingSafeMethod
+  # :reek:SubclassedFromCoreClass
+  class TagList < Array
+    # :reek:Attribute
+    attr_accessor :taggable
+    attr_reader :tag_definition
+
+    def initialize(tag_definition, *args)
+      @tag_definition = tag_definition
+
+      add(*args)
+    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.
+    #
+    # Example:
+    #   tag_list.add("Fun", "Happy")
+    #   tag_list.add("Fun, Happy", :parse => true)
+    def add(*names)
+      extract_and_apply_options!(names)
+      concat(names)
+      clean!
+
+      self
+    end
+
+    # Append---Add the tag to the tag_list. This
+    # expression returns the tag_list itself, so several appends
+    # may be chained together.
+    def <<(obj)
+      add(obj)
+    end
+
+    # 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)
+    end
+
+    # Appends the elements of +other_tag_list+ to +self+.
+    def concat(other_tag_list)
+      notify_will_change
+
+      super(other_tag_list).send(:clean!)
+
+      self
+    end
+
+    ##
+    # Remove specific tags from the tag_list.
+    # Use the <tt>:parse</tt> option to add an unparsed tag string.
+    #
+    # Example:
+    #   tag_list.remove("Sad", "Lonely")
+    #   tag_list.remove("Sad, Lonely", :parse => true)
+    def remove(*names)
+      remove_list = ActsAsTaggableOnMongoid::TagList.new(tag_definition, *names)
+
+      notify_will_change
+
+      delete_if { |name| remove_list.include?(name) }
+
+      self
+    end
+
+    ##
+    # Transform the tag_list into a tag string suitable for editing in a form.
+    # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+    #
+    # Example:
+    #   tag_list = TagList.new("Round", "Square,Cube")
+    #   tag_list.to_s # 'Round, "Square,Cube"'
+    def to_s
+      tag_definition.parser.new(*self).to_s
+    end
+
+    def notify_will_change
+      return unless taggable
+
+      taggable.tag_list_on_changed tag_definition
+    end
+
+    # :reek:ManualDispatch
+    def ==(other)
+      if tag_definition.preserve_tag_order?
+        super
+      elsif other.respond_to?(:sort)
+        self&.sort == other.sort
+      end
+    end
+
+    def add_tagging(tagging)
+      orig_taggable = taggable
+      @taggable     = nil
+
+      begin
+        tag = tagging.tag_name
+
+        self << tag unless include?(tag)
+      ensure
+        @taggable = orig_taggable
+      end
+    end
+
+    private
+
+    def clean!
+      reject!(&:blank?)
+
+      map!(&:to_s)
+      map!(&:strip)
+
+      conditional_clean_rules
+    end
+
+    def conditional_clean_rules
+      map! { |tag| tag.mb_chars.downcase.to_s } if tag_definition.force_lowercase?
+      map!(&:parameterize) if tag_definition.force_parameterize?
+
+      uniq!
+
+      self
+    end
+
+    # :reek:FeatureEnvy
+    # :reek:DuplicateMethodCall
+    def extract_and_apply_options!(args)
+      options = args.extract_options!
+      options.assert_valid_keys :parse, :parser
+
+      options_parser = options[:parser]
+      run_parser     = options_parser || tag_definition.parser
+
+      args.flatten!
+      args.map! { |argument| run_parser.new(argument).parse } if options[:parse] || options_parser
+
+      args.flatten!
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable.rb

@@ -0,0 +1,131 @@
+# 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 Taggable
+    extend ActiveSupport::Concern
+
+    # rubocop:disable Metrics/BlockLength
+
+    class_methods do
+      # Options include:
+      #   * parser
+      #     The class to be used to parse strings.
+      #   * preserve_tag_order
+      #     If true, the _list accessor will save and returns tags in the order they are added to the object.
+      #   * cached_in_model
+      #     Not currently supported
+      #   * force_lowercase
+      #     If true, values stored for tags will first be downcased to make the values effectively case-insensitive
+      #   * force_parameterize
+      #     If true, values stored for tags will be parameterized
+      #   * remove_unused_tags
+      #     If true, when there are no more taggings for a tag, the tag will be destroyed
+      #   * tags_table
+      #     The class to use for Tags
+      #   * taggings_table
+      #     The class to use for Taggings
+      #   * default
+      #     A default value.  Any value that can be used for list assignment or adding values to a list
+      #     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]
+
+      ##
+      # This is an alias for calling <tt>acts_as_taggable_on :tags</tt>.
+      #
+      # Example:
+      #   class Book < ActiveRecord::Base
+      #     acts_as_taggable
+      #   end
+      def acts_as_taggable(options = {})
+        acts_as_taggable_on :tags, options
+      end
+
+      ##
+      # This is an alias for calling <tt>acts_as_ordered_taggable_on :tags</tt>.
+      #
+      # Example:
+      #   class Book < ActiveRecord::Base
+      #     acts_as_ordered_taggable
+      #   end
+      def acts_as_ordered_taggable(options = {})
+        acts_as_ordered_taggable_on :tags, options
+      end
+
+      ##
+      # Make a model taggable on specified contexts.
+      #
+      # @param [Array] tag_types An array of taggable contexts
+      #
+      # Example:
+      #   class User < ActiveRecord::Base
+      #     acts_as_taggable_on :languages, :skills
+      #   end
+      def acts_as_taggable_on(*tag_types)
+        taggable_on(*tag_types)
+      end
+
+      ##
+      # Make a model taggable on specified contexts
+      # and preserves the order in which tags are created.
+      #
+      # An alias for acts_as_taggable_on *tag_types, preserve_tag_order: true
+      #
+      # @param [Array] tag_types An array of taggable contexts
+      #
+      # Example:
+      #   class User < ActiveRecord::Base
+      #     acts_as_ordered_taggable_on :languages, :skills
+      #   end
+      def acts_as_ordered_taggable_on(*tag_types)
+        options = tag_types.extract_options!
+
+        taggable_on(*tag_types, options.merge(preserve_tag_order: true))
+      end
+
+      private
+
+      # Make a model taggable on specified contexts
+      # and optionally preserves the order in which tags are created
+      #
+      # Separate methods used above for backwards compatibility
+      # so that the original acts_as_taggable_on method is unaffected
+      # as it's not possible to add another argument to the method
+      # without the tag_types being enclosed in square brackets
+      #
+      # NB: method overridden in core module in order to create tag type
+      #     associations and methods after this logic has executed
+      #
+      def taggable_on(*tag_types)
+        # if we are actually defining tags on a module, add these modules to add hooks and global methods
+        # used by tagging.  We only add them dynamically like this so that they don't bloat the model
+        # and add hooks/callbacks that aren't needed without tags.
+        [ActsAsTaggableOnMongoid::Taggable::Core,
+         ActsAsTaggableOnMongoid::Taggable::Changeable,
+         # 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::ListTags].each do |include_module|
+          include include_module unless included_modules.include?(include_module)
+        end
+
+        options = tag_types.extract_options!
+        tag_types.flatten!
+
+        tag_types.each do |tag_type|
+          next if tag_type.blank?
+
+          define_tag tag_type, options
+        end
+      end
+    end
+
+    # rubocop:enable Metrics/BlockLength
+  end
+end