acts-as-taggable-on-mongoid 6.0.1.1

data/lib/acts_as_taggable_on_mongoid/taggable/changeable.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    # Overides of methods from Mongoid::Changeable
+    module Changeable
+      def tag_list_on_changed(tag_definition)
+        attribute_will_change!(tag_definition.tag_list_name)
+      end
+
+      def reload(*args)
+        tag_types.each_value do |tag_definition|
+          instance_variable_set tag_definition.all_tag_list_variable_name, nil
+          instance_variable_set tag_definition.tag_list_variable_name, nil
+        end
+
+        super(*args)
+      end
+
+      def changed
+        changed_values = super
+        tag_list_names = tag_types.values.map(&:tag_list_name).map(&:to_s)
+
+        changed_attributes.each_key do |key|
+          next unless tag_list_names.include?(key.to_s)
+
+          if public_send("#{key}_changed?")
+            changed_values << key unless changed_values.include?(key)
+          else
+            changed_values.delete(key)
+          end
+        end
+
+        changed_values
+      end
+
+      def changes
+        changed_values = super
+
+        tag_types.each_value do |tag_definition|
+          tag_list_name = tag_definition.tag_list_name
+
+          next unless changed_attributes.key? tag_list_name
+
+          changed_values[tag_list_name] = [changed_attributes[tag_list_name], public_send(tag_list_name)]
+        end
+
+        changed_values
+      end
+
+      def setters
+        setter_values  = super
+        tag_list_names = tag_types.values.map(&:tag_list_name).map(&:to_s)
+
+        setter_values.delete_if do |key, _value|
+          tag_list_names.include?(key.to_s)
+        end
+      end
+
+      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 }
+
+        return if changed_attributes.key?(attribute_name)
+
+        changed_attributes[attribute_name] = public_send(attribute_name)&.dup
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/core.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    # A collection of generic methods which use the tag definition to perform actions.
+    #
+    # These methods are called by the individual tag generated methods to do their work so that
+    # the code can be defined in only one location and "shared" by all tags rather than putting the code
+    # and definitions into the dynamically defined methods directly.
+    #
+    # This module actually consists almost exclusively of utility functions
+
+    # :reek:FeatureEnvy
+    # :reek:UtilityFunction
+    module Core
+      extend ActiveSupport::Concern
+
+      DYNAMIC_MODULE_NAME = :DynamicAttributes
+
+      included do
+        # TODO: allow custom contexts
+        # attr_writer :custom_contexts
+
+        after_save :save_tags
+      end
+
+      class_methods do
+        def taggable_mixin
+          # https://thepugautomatic.com/2013/07/dsom/
+          # Provides a description of what we're doing here and why.
+          if const_defined?(DYNAMIC_MODULE_NAME, false)
+            mod = const_get(DYNAMIC_MODULE_NAME)
+          else
+            mod = const_set(DYNAMIC_MODULE_NAME, Module.new)
+
+            include mod
+          end
+
+          mod
+        end
+      end
+
+      def apply_pre_processed_defaults
+        super
+
+        set_tag_list_defaults
+      end
+
+      private
+
+      def tag_list_cache_set_on(tag_definition)
+        variable_name = tag_definition.tag_list_variable_name
+
+        instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
+      end
+
+      def tag_list_cache_on(tag_definition)
+        variable_name = tag_definition.tag_list_variable_name
+
+        # if instance_variable_get(variable_name)
+        #   instance_variable_get(variable_name)
+        # elsif cached_tag_list_on(tag_definition) && ensure_included_cache_methods! && self.class.caching_tag_list_on?(tag_definition)
+        #   instance_variable_set(variable_name, tag_definition.parse(cached_tag_list_on(tag_definition)))
+        # else
+        #   tag_list_set(ActsAsTaggableOnMongoid::TagList.new(tag_definition, tags_on(tag_definition).map(&:tag_name)))
+        # end
+
+        instance_variable_get(variable_name) ||
+            tag_list_set(ActsAsTaggableOnMongoid::TagList.new(tag_definition, tags_on(tag_definition).map(&:tag_name)))
+      end
+
+      def tag_list_on(tag_definition)
+        # add_custom_context(tag_definition)
+
+        tag_list_cache_on(tag_definition)
+      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)
+      end
+
+      ##
+      # Returns all tags of a given context
+      def all_tags_on(tag_definition)
+        tag_definition.tags_table.for_tag(tag_definition).to_a
+      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)
+
+        # 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
+
+      def mark_tag_list_changed(new_list)
+        tag_definition   = new_list.tag_definition
+        current_tag_list = public_send(tag_definition.tag_list_name)
+
+        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
+      end
+
+      def tag_list_set(new_list)
+        # add_custom_context(tag_definition, owner)
+
+        new_list.taggable = self
+
+        instance_variable_set(new_list.tag_definition.tag_list_variable_name, new_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)
+      end
+
+      def set_tag_list_defaults
+        return unless new_record?
+
+        tag_types.each_value do |tag_definition|
+          default = tag_definition.default
+          next unless default.present?
+
+          tag_list_name = tag_definition.tag_list_name
+          next if public_send(tag_list_name).present?
+
+          public_send("#{tag_list_name}=", default)
+        end
+      end
+
+      def save_tags
+        # Don't call save_tags again if a related classes save while processing this funciton causes this object to re-save.
+        return if @saving_tag_list
+
+        @saving_tag_list = true
+
+        tag_types.each_value do |tag_definition|
+          next unless tag_list_cache_set_on(tag_definition)
+
+          # List of currently assigned tag names
+          tag_list_diff = extract_tag_list_changes(tag_definition)
+
+          # Destroy old taggings:
+          tag_list_diff.destroy_old_tags self
+
+          # Create new taggings:
+          tag_list_diff.create_new_tags self
+        end
+
+        @saving_tag_list = false
+
+        true
+      end
+
+      def extract_tag_list_changes(tag_definition)
+        tag_list = tag_list_cache_on(tag_definition).uniq
+
+        # 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
+
+        tag_list_diff = ActsAsTaggableOnMongoid::Taggable::Utils::TagListDiff.new tag_definition: tag_definition,
+                                                                                  tags:           tags,
+                                                                                  current_tags:   current_tags
+
+        tag_list_diff.call
+
+        tag_list_diff
+      end
+
+      def dirtify_tag_list(tagging)
+        tag_definition = tag_types[tagging.context]
+
+        return unless tag_definition
+
+        attribute_will_change! tag_definition.tag_list_name
+      end
+
+      ##
+      # Imported from `ActsAsTaggableOn`.  It is simply easier to define a custom Tag class and define
+      # the tag to use that Tag class.
+      #
+      # Override this hook if you wish to subclass {ActsAsTaggableOn::Tag} --
+      # context is provided so that you may conditionally use a Tag subclass
+      # only for some contexts.
+      #
+      # @example Custom Tag class for one context
+      #   class Company < ActiveRecord::Base
+      #     acts_as_taggable_on :markets, :locations
+      #
+      #     def find_or_create_tags_from_list_with_context(tag_list)
+      #       if context.to_sym == :markets
+      #         MarketTag.find_or_create_all_with_like_by_name(tag_list)
+      #       else
+      #         super
+      #       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)
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/list_tags.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    # This module adds methods for tracking tag definitions within Taggable classes
+    module ListTags
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :tag_types
+
+        self.tag_types ||= {}.with_indifferent_access
+      end
+
+      def tag_definition(tag_type)
+        return unless tag_type.present?
+
+        tag_types[tag_type] ||= ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition.new(self, tag_type)
+      end
+
+      class_methods do
+        # In order to allow dynamic tags, return a default tag_definition for any missing tag_type.
+        # This means that any dynamic tag necessarily is created with the current defaults
+        def define_tag(tag_type, options = {})
+          return if tag_type.blank?
+
+          tag_definition = tag_types[tag_type]
+
+          return tag_definition if tag_definition
+
+          # tag_types is a class_attribute
+          # As such, we have to replace it each time with a new array so that inherited classes and instances
+          # are able to maintain separate lists if need be.
+          new_tag_types  = {}.with_indifferent_access.merge!(self.tag_types || {})
+          self.tag_types = new_tag_types
+          tag_definition = new_tag_types[tag_type] = ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition.new(self, tag_type, options)
+
+          tag_definition.define_base_relations
+          tag_definition.define_relations
+          tag_definition.add_tag_list
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/tag_type_definition.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    # TagTypeDefinition represents the definition for a aingle tag_type in a model.
+    #
+    # The options passed into a tag_type defined through acts_as_taggable* method are stored in the tag definition
+    # which then drives the creation of the relations and methods that are added to the model.
+    #
+    # The TagTypeDefinition mirrors the Configuraiton attributes and defaults any value that isn't passed in
+    # to the value in the Configuration (ActsAsTaggableOnMongoid.configuration)
+    class TagTypeDefinition
+      attr_reader :owner,
+                  :tag_type
+
+      include ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition::Attributes
+      include ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition::Names
+      include ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition::Changeable
+
+      def initialize(owner, tag_type, 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)
+
+        options.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+
+        @owner    = owner
+        @tag_type = tag_type
+      end
+
+      # rubocop:disable Layout/SpaceAroundOperators
+      # :reek:FeatureEnvy
+
+      # I've defined the parser as being required to return an array of strings.
+      # This parse function will take that array and make it a TagList which will then use the tag_definition
+      # to apply the rules to that list (like case sensitivity and parameterization, etc.) to get the final
+      # list.
+      def parse(*tag_list)
+        options          = tag_list.extract_options!
+        options[:parser] ||= parser if options.key?(:parse) || options.key?(:parser)
+
+        ActsAsTaggableOnMongoid::TagList.new(self, *tag_list, options)
+      end
+
+      # rubocop:enable Layout/SpaceAroundOperators
+
+      def taggings_order
+        @taggings_order = if preserve_tag_order?
+                            [:created_at.asc, :id.asc]
+                          else
+                            []
+                          end
+      end
+
+      def define_base_relations
+        tag_definition = self
+
+        add_base_tags_method
+
+        owner.class_eval do
+          taggings_name = tag_definition.taggings_name
+
+          break if relations[taggings_name.to_s]
+
+          has_many taggings_name,
+                   as:           :taggable,
+                   dependent:    :destroy,
+                   class_name:   tag_definition.taggings_table.name,
+                   after_add:    :dirtify_tag_list,
+                   after_remove: :dirtify_tag_list
+        end
+      end
+
+      # Mongoid does not allow the `through` option for relations, so we de-normalize data and manually add the methods we need
+      # for through like functionality.
+      def add_base_tags_method
+        tag_definition   = self
+        base_tags_method = tag_definition.base_tags_method
+
+        owner.taggable_mixin.module_eval do
+          break if methods.include?(base_tags_method)
+
+          define_method base_tags_method do
+            tag_definition.tags_table.where(taggable_type: tag_definition.owner.name)
+          end
+        end
+      end
+
+      def define_relations
+        # Relations cannot be added for the tags and taggings like they are in ActiveRecord because
+        # Mongoid does not allow for a scope like ActiveRecord does.
+        #
+        # Therefore the relation like actions will have to be defined separately ourselves.  If any
+        # relation actions are missed, we'll just have to fix it here when we find them.
+        # (This is far from ideal, but it is the only way to work around the issue at this time.)
+
+        add_context_taggings_method
+        add_context_tags_method
+      end
+
+      def add_context_taggings_method
+        tag_definition = self
+        taggings_name  = tag_definition.taggings_name
+
+        owner.taggable_mixin.module_eval do
+          define_method "#{tag_definition.single_tag_type}_#{taggings_name}".to_sym do
+            public_send(taggings_name).
+                order_by(*tag_definition.taggings_order).
+                for_tag(tag_definition)
+          end
+        end
+      end
+
+      def add_context_tags_method
+        tag_definition = self
+
+        owner.taggable_mixin.module_eval do
+          define_method tag_definition.tag_type.to_sym do
+            public_send("#{tag_definition.single_tag_type}_#{tag_definition.taggings_name}").map(&:tag)
+          end
+        end
+      end
+
+      def add_tag_list
+        add_list_getter
+        add_list_setter
+        add_all_list_getter
+        add_list_exists
+        add_list_change
+        add_list_changed
+        add_changed_from_default?
+        add_will_change
+        add_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|
+            new_tags        = Array.wrap(new_tags)
+            options         = new_tags.extract_options!
+            options[:parse] = true unless options.key?(:parse)
+
+            new_list = tag_definition.parse(*new_tags, options)
+
+            mark_tag_list_changed(new_list)
+            tag_list_set(new_list)
+          end
+        end
+      end
+
+      def add_all_list_getter
+        tag_definition = self
+
+        owner.taggable_mixin.module_eval do
+          define_method(tag_definition.all_tag_list_name) do
+            all_tags_list_on tag_definition
+          end
+        end
+      end
+    end
+  end
+end