acts-as-taggable-on 7.0.0 → 9.0.1

data/lib/acts_as_taggable_on/taggable/ownership.rb

@@ -1,136 +1,148 @@
-module ActsAsTaggableOn::Taggable
-  module Ownership
-    def self.included(base)
-      base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
+# frozen_string_literal: true
 
-      base.class_eval do
-        after_save :save_owned_tags
-      end
+module ActsAsTaggableOn
+  module Taggable
+    module Ownership
+      def self.included(base)
+        base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
 
-      base.initialize_acts_as_taggable_on_ownership
-    end
+        base.class_eval do
+          after_save :save_owned_tags
+        end
 
-    module ClassMethods
-      def acts_as_taggable_on(*args)
-        initialize_acts_as_taggable_on_ownership
-        super(*args)
+        base.initialize_acts_as_taggable_on_ownership
       end
 
-      def initialize_acts_as_taggable_on_ownership
-        tag_types.map(&:to_s).each do |tag_type|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      module ClassMethods
+        def acts_as_taggable_on(*args)
+          initialize_acts_as_taggable_on_ownership
+          super(*args)
+        end
+
+        def initialize_acts_as_taggable_on_ownership
+          tag_types.map(&:to_s).each do |tag_type|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{tag_type}_from(owner)
               owner_tag_list_on(owner, '#{tag_type}')
             end
-          RUBY
+            RUBY
+          end
+        end
+      end
+
+      def owner_tags(owner)
+        scope = if owner.nil?
+                  base_tags
+                else
+                  base_tags.where(
+                    ActsAsTaggableOn::Tagging.table_name.to_s => {
+                      tagger_id: owner.id,
+                      tagger_type: owner.class.base_class.to_s
+                    }
+                  )
+                end
+
+        # when preserving tag order, return tags in created order
+        # if we added the order to the association this would always apply
+        if self.class.preserve_tag_order?
+          scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id")
+        else
+          scope
         end
       end
-    end
 
-    def owner_tags(owner)
-      if owner.nil?
-        scope = base_tags
-      else
-        scope = base_tags.where(
-          "#{ActsAsTaggableOn::Tagging.table_name}" => {
-            tagger_id: owner.id,
-            tagger_type: owner.class.base_class.to_s
+      def owner_tags_on(owner, context)
+        owner_tags(owner).where(
+          ActsAsTaggableOn::Tagging.table_name.to_s => {
+            context: context
           }
         )
       end
 
-      # when preserving tag order, return tags in created order
-      # if we added the order to the association this would always apply
-      if self.class.preserve_tag_order?
-        scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id")
-      else
-        scope
+      def cached_owned_tag_list_on(context)
+        variable_name = "@owned_#{context}_list"
+        (instance_variable_defined?(variable_name) && instance_variable_get(variable_name)) || instance_variable_set(
+          variable_name, {}
+        )
       end
-    end
-
-    def owner_tags_on(owner, context)
-      owner_tags(owner).where(
-        "#{ActsAsTaggableOn::Tagging.table_name}" => {
-          context: context
-        }
-      )
-    end
-
-    def cached_owned_tag_list_on(context)
-      variable_name = "@owned_#{context}_list"
-      (instance_variable_defined?(variable_name) && instance_variable_get(variable_name)) || instance_variable_set(variable_name, {})
-    end
-
-    def owner_tag_list_on(owner, context)
-      add_custom_context(context)
 
-      cache = cached_owned_tag_list_on(context)
+      def owner_tag_list_on(owner, context)
+        add_custom_context(context)
 
-      cache[owner] ||= ActsAsTaggableOn::TagList.new(*owner_tags_on(owner, context).map(&:name))
-    end
-
-    def set_owner_tag_list_on(owner, context, new_list)
-      add_custom_context(context)
-
-      cache = cached_owned_tag_list_on(context)
-
-      cache[owner] = ActsAsTaggableOn.default_parser.new(new_list).parse
-    end
+        cache = cached_owned_tag_list_on(context)
 
-    def reload(*args)
-      self.class.tag_types.each do |context|
-        instance_variable_set("@owned_#{context}_list", nil)
+        cache[owner] ||= ActsAsTaggableOn::TagList.new(*owner_tags_on(owner, context).map(&:name))
       end
 
-      super(*args)
-    end
-
-    def save_owned_tags
-      tagging_contexts.each do |context|
-        cached_owned_tag_list_on(context).each do |owner, tag_list|
+      def set_owner_tag_list_on(owner, context, new_list)
+        add_custom_context(context)
 
-          # Find existing tags or create non-existing tags:
-          tags = find_or_create_tags_from_list_with_context(tag_list.uniq, context)
+        cache = cached_owned_tag_list_on(context)
 
-          # Tag objects for owned tags
-          owned_tags = owner_tags_on(owner, context).to_a
+        cache[owner] = ActsAsTaggableOn.default_parser.new(new_list).parse
+      end
 
-          # Tag maintenance based on whether preserving the created order of tags
-          if self.class.preserve_tag_order?
-            old_tags, new_tags = owned_tags - tags, tags - owned_tags
+      def reload(*args)
+        self.class.tag_types.each do |context|
+          instance_variable_set("@owned_#{context}_list", nil)
+        end
 
-            shared_tags = owned_tags & tags
+        super(*args)
+      end
 
-            if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
-              index = shared_tags.each_with_index { |_, i| break i unless shared_tags[i] == tags[i] }
+      def save_owned_tags
+        tagging_contexts.each do |context|
+          cached_owned_tag_list_on(context).each do |owner, tag_list|
+            # Find existing tags or create non-existing tags:
+            tags = find_or_create_tags_from_list_with_context(tag_list.uniq, context)
 
-              # Update arrays of tag objects
-              old_tags |= owned_tags.from(index)
-              new_tags |= owned_tags.from(index) & shared_tags
+            # Tag objects for owned tags
+            owned_tags = owner_tags_on(owner, context).to_a
 
-              # Order the array of tag objects to match the tag list
-              new_tags = tags.map { |t| new_tags.find { |n| n.name.downcase == t.name.downcase } }.compact
-            end
-          else
-            # Delete discarded tags and create new tags
+            # Tag maintenance based on whether preserving the created order of tags
             old_tags = owned_tags - tags
             new_tags = tags - owned_tags
-          end
+            if self.class.preserve_tag_order?
+
+              shared_tags = owned_tags & tags
+
+              if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
+                index = shared_tags.each_with_index do |_, i|
+                  break i unless shared_tags[i] == tags[i]
+                end
+
+                # Update arrays of tag objects
+                old_tags |= owned_tags.from(index)
+                new_tags |= owned_tags.from(index) & shared_tags
+
+                # Order the array of tag objects to match the tag list
+                new_tags = tags.map do |t|
+                  new_tags.find do |n|
+                    n.name.downcase == t.name.downcase
+                  end
+                end.compact
+              end
+            else
+              # Delete discarded tags and create new tags
+            end
 
-          # Find all taggings that belong to the taggable (self), are owned by the owner,
-          # have the correct context, and are removed from the list.
-          ActsAsTaggableOn::Tagging.where(taggable_id: id, taggable_type: self.class.base_class.to_s,
-                                          tagger_type: owner.class.base_class.to_s, tagger_id: owner.id,
-                                          tag_id: old_tags, context: context).destroy_all if old_tags.present?
+            # Find all taggings that belong to the taggable (self), are owned by the owner,
+            # have the correct context, and are removed from the list.
+            if old_tags.present?
+              ActsAsTaggableOn::Tagging.where(taggable_id: id, taggable_type: self.class.base_class.to_s,
+                                              tagger_type: owner.class.base_class.to_s, tagger_id: owner.id,
+                                              tag_id: old_tags, context: context).destroy_all
+            end
 
-          # Create new taggings:
-          new_tags.each do |tag|
-            taggings.create!(tag_id: tag.id, context: context.to_s, tagger: owner, taggable: self)
+            # Create new taggings:
+            new_tags.each do |tag|
+              taggings.create!(tag_id: tag.id, context: context.to_s, tagger: owner, taggable: self)
+            end
           end
         end
-      end
 
-      true
+        true
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/related.rb

@@ -1,14 +1,17 @@
-module ActsAsTaggableOn::Taggable
-  module Related
-    def self.included(base)
-      base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
-      base.initialize_acts_as_taggable_on_related
-    end
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module Related
+      def self.included(base)
+        base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
+        base.initialize_acts_as_taggable_on_related
+      end
 
-    module ClassMethods
-      def initialize_acts_as_taggable_on_related
-        tag_types.map(&:to_s).each do |tag_type|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      module ClassMethods
+        def initialize_acts_as_taggable_on_related
+          tag_types.map(&:to_s).each do |tag_type|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def find_related_#{tag_type}(options = {})
               related_tags_for('#{tag_type}', self.class, options)
             end
@@ -17,55 +20,65 @@ module ActsAsTaggableOn::Taggable
             def find_related_#{tag_type}_for(klass, options = {})
               related_tags_for('#{tag_type}', klass, options)
             end
-          RUBY
+            RUBY
+          end
         end
-      end
 
-      def acts_as_taggable_on(*args)
-        super(*args)
-        initialize_acts_as_taggable_on_related
+        def acts_as_taggable_on(*args)
+          super(*args)
+          initialize_acts_as_taggable_on_related
+        end
       end
-    end
 
-    def find_matching_contexts(search_context, result_context, options = {})
-      matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
-    end
+      def find_matching_contexts(search_context, result_context, options = {})
+        matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
+      end
 
-    def find_matching_contexts_for(klass, search_context, result_context, options = {})
-      matching_contexts_for(search_context.to_s, result_context.to_s, klass, options)
-    end
+      def find_matching_contexts_for(klass, search_context, result_context, options = {})
+        matching_contexts_for(search_context.to_s, result_context.to_s, klass, options)
+      end
 
-    def matching_contexts_for(search_context, result_context, klass, options = {})
-      tags_to_find = tags_on(search_context).map { |t| t.name }
-      related_where(klass, ["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context])
-    end
+      def matching_contexts_for(search_context, result_context, klass, _options = {})
+        tags_to_find = tags_on(search_context).map(&:name)
+        related_where(klass,
+                      [
+                        "#{exclude_self(klass,
+                                        id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context
+                      ])
+      end
 
-    def related_tags_for(context, klass, options = {})
-      tags_to_ignore = Array.wrap(options[:ignore]).map(&:to_s) || []
-      tags_to_find = tags_on(context).map { |t| t.name }.reject { |t| tags_to_ignore.include? t }
-      related_where(klass, ["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, context])
-    end
+      def related_tags_for(context, klass, options = {})
+        tags_to_ignore = Array.wrap(options[:ignore]).map(&:to_s) || []
+        tags_to_find = tags_on(context).map(&:name).reject { |t| tags_to_ignore.include? t }
+        related_where(klass,
+                      [
+                        "#{exclude_self(klass,
+                                        id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, context
+                      ])
+      end
 
-    private
+      private
 
-    def exclude_self(klass, id)
-      "#{klass.arel_table[klass.primary_key].not_eq(id).to_sql} AND" if [self.class.base_class, self.class].include? klass
-    end
+      def exclude_self(klass, id)
+        "#{klass.arel_table[klass.primary_key].not_eq(id).to_sql} AND" if [self.class.base_class,
+                                                                           self.class].include? klass
+      end
 
-    def group_columns(klass)
-      if ActsAsTaggableOn::Utils.using_postgresql?
-        grouped_column_names_for(klass)
-      else
-        "#{klass.table_name}.#{klass.primary_key}"
+      def group_columns(klass)
+        if ActsAsTaggableOn::Utils.using_postgresql?
+          grouped_column_names_for(klass)
+        else
+          "#{klass.table_name}.#{klass.primary_key}"
+        end
       end
-    end
 
-    def related_where(klass, conditions)
-      klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count")
-      .from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}")
-      .group(group_columns(klass))
-      .order('count DESC')
-      .where(conditions)
+      def related_where(klass, conditions)
+        klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count")
+             .from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}")
+             .group(group_columns(klass))
+             .order('count DESC')
+             .where(conditions)
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/tag_list_type.rb

@@ -1,4 +1,8 @@
-module ActsAsTaggableOn::Taggable
-  class TagListType < ActiveModel::Type::Value
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    class TagListType < ActiveModel::Type::Value
+    end
   end
 end

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

@@ -1,111 +1,115 @@
-module ActsAsTaggableOn::Taggable::TaggedWithQuery
-  class AllTagsQuery < QueryBase
-    def build
-      taggable_model.joins(each_tag_in_list)
-                    .group(by_taggable)
-                    .having(tags_that_matches_count)
-                    .order(order_conditions)
-                    .readonly(false)
-    end
-
-    private
-
-    def each_tag_in_list
-      arel_join = taggable_arel_table
-
-      tag_list.each do |tag|
-        tagging_alias = tagging_arel_table.alias(tagging_alias(tag))
-        arel_join = arel_join
-                      .join(tagging_alias)
-                      .on(on_conditions(tag, tagging_alias))
-      end
-
-      if options[:match_all].present?
-        arel_join = arel_join
-          .join(tagging_arel_table, Arel::Nodes::OuterJoin)
-          .on(
-            match_all_on_conditions
-          )
-      end
-
-      return arel_join.join_sources
-    end
-
-    def on_conditions(tag, tagging_alias)
-      on_condition = tagging_alias[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
-        .and(tagging_alias[:taggable_type].eq(taggable_model.base_class.name))
-        .and(
-          tagging_alias[:tag_id].in(
-            tag_arel_table.project(tag_arel_table[:id]).where(tag_match_type(tag))
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class AllTagsQuery < QueryBase
+        def build
+          taggable_model.joins(each_tag_in_list)
+                        .group(by_taggable)
+                        .having(tags_that_matches_count)
+                        .order(order_conditions)
+                        .readonly(false)
+        end
+
+        private
+
+        def each_tag_in_list
+          arel_join = taggable_arel_table
+
+          tag_list.each do |tag|
+            tagging_alias = tagging_arel_table.alias(tagging_alias(tag))
+            arel_join = arel_join
+                        .join(tagging_alias)
+                        .on(on_conditions(tag, tagging_alias))
+          end
+
+          if options[:match_all].present?
+            arel_join = arel_join
+                        .join(tagging_arel_table, Arel::Nodes::OuterJoin)
+                        .on(
+                          match_all_on_conditions
+                        )
+          end
+
+          arel_join.join_sources
+        end
+
+        def on_conditions(tag, tagging_alias)
+          on_condition = tagging_alias[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                    .and(tagging_alias[:taggable_type].eq(taggable_model.base_class.name))
+                                                    .and(
+                                                      tagging_alias[:tag_id].in(
+                                                        tag_arel_table.project(tag_arel_table[:id]).where(tag_match_type(tag))
+                                                      )
+                                                    )
+
+          if options[:start_at].present?
+            on_condition = on_condition.and(tagging_alias[:created_at].gteq(options[:start_at]))
+          end
+
+          if options[:end_at].present?
+            on_condition = on_condition.and(tagging_alias[:created_at].lteq(options[:end_at]))
+          end
+
+          on_condition = on_condition.and(tagging_alias[:context].eq(options[:on])) if options[:on].present?
+
+          if (owner = options[:owned_by]).present?
+            on_condition = on_condition.and(tagging_alias[:tagger_id].eq(owner.id))
+                                       .and(tagging_alias[:tagger_type].eq(owner.class.base_class.to_s))
+          end
+
+          on_condition
+        end
+
+        def match_all_on_conditions
+          on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                         .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+
+          if options[:start_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+          end
+
+          if options[:end_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+          end
+
+          on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on])) if options[:on].present?
+
+          on_condition
+        end
+
+        def by_taggable
+          return [] if options[:match_all].blank?
+
+          taggable_arel_table[taggable_model.primary_key]
+        end
+
+        def tags_that_matches_count
+          return [] if options[:match_all].blank?
+
+          taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
+
+          tagging_arel_table[:taggable_id].count.eq(
+            tag_arel_table.project(Arel.star.count).where(tags_match_type)
           )
-        )
-
-      if options[:start_at].present?
-        on_condition = on_condition.and(tagging_alias[:created_at].gteq(options[:start_at]))
-      end
-
-      if options[:end_at].present?
-        on_condition = on_condition.and(tagging_alias[:created_at].lteq(options[:end_at]))
-      end
-
-      if options[:on].present?
-        on_condition = on_condition.and(tagging_alias[:context].eq(options[:on]))
-      end
-
-      if (owner = options[:owned_by]).present?
-        on_condition = on_condition.and(tagging_alias[:tagger_id].eq(owner.id))
-                                   .and(tagging_alias[:tagger_type].eq(owner.class.base_class.to_s))
-      end
-
-      on_condition
-    end
-
-    def match_all_on_conditions
-      on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
-                      .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
-
-      if options[:start_at].present?
-        on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
-      end
-
-      if options[:end_at].present?
-        on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+        end
+
+        def order_conditions
+          order_by = []
+          if options[:order_by_matching_tag_count].present? && options[:match_all].blank?
+            order_by << tagging_arel_table.project(tagging_arel_table[Arel.star].count.as('taggings_count')).order('taggings_count DESC').to_sql
+          end
+
+          order_by << options[:order] if options[:order].present?
+          order_by.join(', ')
+        end
+
+        def tagging_alias(tag)
+          alias_base_name = taggable_model.base_class.name.downcase
+          adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag)}")
+        end
       end
-
-      if options[:on].present?
-        on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on]))
-      end
-
-      on_condition
-    end
-
-    def by_taggable
-      return [] unless options[:match_all].present?
-
-      taggable_arel_table[taggable_model.primary_key]
-    end
-
-    def tags_that_matches_count
-      return [] unless options[:match_all].present?
-
-      taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
-
-      tagging_arel_table[:taggable_id].count.eq(
-        tag_arel_table.project(Arel.star.count).where(tags_match_type)
-      )
-    end
-
-    def order_conditions
-      order_by = []
-      order_by << tagging_arel_table.project(tagging_arel_table[Arel.star].count.as('taggings_count')).order('taggings_count DESC').to_sql if options[:order_by_matching_tag_count].present? && options[:match_all].blank?
-
-      order_by << options[:order] if options[:order].present?
-      order_by.join(', ')
-    end
-
-    def tagging_alias(tag)
-      alias_base_name = taggable_model.base_class.name.downcase
-      adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag)}")
     end
   end
 end