acts-as-taggable-on 4.0.0 → 8.0.0

data/lib/acts_as_taggable_on/taggable/ownership.rb

@@ -27,13 +27,16 @@ module ActsAsTaggableOn::Taggable
       end
     end
 
-    def owner_tags_on(owner, context)
+    def owner_tags(owner)
       if owner.nil?
-        scope = base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ?), context.to_s])
+        scope = base_tags
       else
-        scope = base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ? AND
-                                    #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = ? AND
-                                    #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = ?), context.to_s, owner.id, owner.class.base_class.to_s])
+        scope = base_tags.where(
+          "#{ActsAsTaggableOn::Tagging.table_name}" => {
+            tagger_id: owner.id,
+            tagger_type: owner.class.base_class.to_s
+          }
+        )
       end
 
       # when preserving tag order, return tags in created order
@@ -45,6 +48,14 @@ module ActsAsTaggableOn::Taggable
       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, {})

data/lib/acts_as_taggable_on/taggable/related.rb

@@ -49,7 +49,7 @@ module ActsAsTaggableOn::Taggable
     private
 
     def exclude_self(klass, id)
-      "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
+      "#{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)

data/lib/acts_as_taggable_on/taggable/tag_list_type.rb

@@ -0,0 +1,4 @@
+module ActsAsTaggableOn::Taggable
+  class TagListType < ActiveModel::Type::Value
+  end
+end

data/lib/acts_as_taggable_on/taggable/tagged_with_query.rb

@@ -0,0 +1,16 @@
+require_relative 'tagged_with_query/query_base'
+require_relative 'tagged_with_query/exclude_tags_query'
+require_relative 'tagged_with_query/any_tags_query'
+require_relative 'tagged_with_query/all_tags_query'
+
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  def self.build(taggable_model, tag_model, tagging_model, tag_list, options)
+    if options[:exclude].present?
+      ExcludeTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+    elsif options[:any].present?
+      AnyTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+    else
+      AllTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+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))
+          )
+        )
+
+      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
+
+      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

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

@@ -0,0 +1,70 @@
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  class AnyTagsQuery < QueryBase
+    def build
+      taggable_model.select(all_fields)
+                    .where(model_has_at_least_one_tag)
+                    .order(Arel.sql(order_conditions))
+                    .readonly(false)
+    end
+
+    private
+
+    def all_fields
+      taggable_arel_table[Arel.star]
+    end
+
+    def model_has_at_least_one_tag
+      tagging_arel_table.project(Arel.star).where(at_least_one_tag).exists
+    end
+
+    def at_least_one_tag
+      exists_contition = 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))
+                          .and(
+                            tagging_arel_table[:tag_id].in(
+                              tag_arel_table.project(tag_arel_table[:id]).where(tags_match_type)
+                            )
+                          )
+
+      if options[:start_at].present?
+        exists_contition = exists_contition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+      end
+
+      if options[:end_at].present?
+        exists_contition = exists_contition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+      end
+
+      if options[:on].present?
+        exists_contition = exists_contition.and(tagging_arel_table[:context].eq(options[:on]))
+      end
+
+      if (owner = options[:owned_by]).present?
+        exists_contition = exists_contition.and(tagging_arel_table[:tagger_id].eq(owner.id))
+                                   .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+      end
+
+      exists_contition
+    end
+
+    def order_conditions
+      order_by = []
+      if options[:order_by_matching_tag_count].present?
+        order_by << "(SELECT count(*) FROM #{tagging_model.table_name} WHERE #{at_least_one_tag.to_sql}) desc"
+      end
+
+      order_by << options[:order] if options[:order].present?
+      order_by.join(', ')
+    end
+
+    def alias_name(tag_list)
+      alias_base_name = taggable_model.base_class.name.downcase
+      taggings_context = options[:on] ? "_#{options[:on]}" : ''
+
+      taggings_alias = adjust_taggings_alias(
+          "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag_list.join('_'))}"
+       )
+
+      taggings_alias
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  class ExcludeTagsQuery < QueryBase
+    def build
+      taggable_model.joins(owning_to_tagger)
+                    .where(tags_not_in_list)
+                    .having(tags_that_matches_count)
+                    .readonly(false)
+    end
+
+    private
+
+    def tags_not_in_list
+      return taggable_arel_table[:id].not_in(
+            tagging_arel_table
+              .project(tagging_arel_table[:taggable_id])
+              .join(tag_arel_table)
+              .on(
+                  tagging_arel_table[:tag_id].eq(tag_arel_table[:id])
+                  .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                  .and(tags_match_type)
+                )
+          )
+
+        # FIXME: missing time scope, this is also missing in the original implementation
+    end
+
+
+    def owning_to_tagger
+      return [] unless options[:owned_by].present?
+
+      owner = options[:owned_by]
+
+      arel_join = taggable_arel_table
+        .join(tagging_arel_table)
+        .on(
+            tagging_arel_table[:tagger_id].eq(owner.id)
+            .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+            .and(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[: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 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
+
+      if options[:on].present?
+        on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on]))
+      end
+
+      on_condition
+    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
+  end
+end

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

@@ -0,0 +1,61 @@
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  class QueryBase
+    def initialize(taggable_model, tag_model, tagging_model, tag_list, options)
+      @taggable_model = taggable_model
+      @tag_model      = tag_model
+      @tagging_model  = tagging_model
+      @tag_list       = tag_list
+      @options        = options
+    end
+
+    private
+
+    attr_reader :taggable_model, :tag_model, :tagging_model, :tag_list, :options
+
+    def taggable_arel_table
+      @taggable_arel_table ||= taggable_model.arel_table
+    end
+
+    def tag_arel_table
+      @tag_arel_table ||= tag_model.arel_table
+    end
+
+    def tagging_arel_table
+      @tagging_arel_table ||=tagging_model.arel_table
+    end
+
+    def tag_match_type(tag)
+      matches_attribute = tag_arel_table[:name]
+      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+
+      if options[:wild].present?
+        matches_attribute.matches("%#{escaped_tag(tag)}%", "!", ActsAsTaggableOn.strict_case_match)
+      else
+        matches_attribute.matches(escaped_tag(tag), "!", ActsAsTaggableOn.strict_case_match)
+      end
+    end
+
+    def tags_match_type
+      matches_attribute = tag_arel_table[:name]
+      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+
+      if options[:wild].present?
+        matches_attribute.matches_any(tag_list.map{|tag| "%#{escaped_tag(tag)}%"}, "!", ActsAsTaggableOn.strict_case_match)
+      else
+        matches_attribute.matches_any(tag_list.map{|tag| "#{escaped_tag(tag)}"}, "!", ActsAsTaggableOn.strict_case_match)
+      end
+    end
+
+    def escaped_tag(tag)
+      tag = tag.downcase unless ActsAsTaggableOn.strict_case_match
+      ActsAsTaggableOn::Utils.escape_like(tag)
+    end
+
+    def adjust_taggings_alias(taggings_alias)
+      if taggings_alias.size > 75
+        taggings_alias = 'taggings_alias_' + Digest::SHA1.hexdigest(taggings_alias)
+      end
+      taggings_alias
+    end
+  end
+end

data/lib/acts_as_taggable_on/tagger.rb

@@ -18,14 +18,14 @@ module ActsAsTaggableOn
           owned_taggings_scope = opts.delete(:scope)
 
           has_many :owned_taggings, owned_taggings_scope,
-                   opts.merge(
+                   **opts.merge(
                      as: :tagger,
-                     class_name: ::ActsAsTaggableOn::Tagging,
+                     class_name: '::ActsAsTaggableOn::Tagging',
                      dependent: :destroy
                    )
 
           has_many :owned_tags, -> { distinct },
-                   class_name: ::ActsAsTaggableOn::Tag,
+                   class_name: '::ActsAsTaggableOn::Tag',
                    source: :tag,
                    through: :owned_taggings
         end

data/lib/acts_as_taggable_on/tagging.rb

@@ -1,15 +1,20 @@
 module ActsAsTaggableOn
   class Tagging < ::ActiveRecord::Base #:nodoc:
+    self.table_name = ActsAsTaggableOn.taggings_table
+
+    DEFAULT_CONTEXT = 'tags'
     belongs_to :tag, class_name: '::ActsAsTaggableOn::Tag', counter_cache: ActsAsTaggableOn.tags_counter
     belongs_to :taggable, polymorphic: true
 
-    belongs_to :tagger, {polymorphic: true}.tap {|o| o.merge!(optional: true) if ActsAsTaggableOn::Utils.active_record5? }
+    belongs_to :tagger, polymorphic: true, optional: true
 
     scope :owned_by, ->(owner) { where(tagger: owner) }
     scope :not_owned, -> { where(tagger_id: nil, tagger_type: nil) }
 
-    scope :by_contexts, ->(contexts) { where(context: (contexts || 'tags')) }
-    scope :by_context, ->(context = 'tags') { by_contexts(context.to_s) }
+    scope :by_contexts, ->(contexts) { where(context: (contexts || DEFAULT_CONTEXT)) }
+    scope :by_context, ->(context = DEFAULT_CONTEXT) { by_contexts(context.to_s) }
+
+    scope :by_tenant, ->(tenant) { where(tenant: tenant) }
 
     validates_presence_of :context
     validates_presence_of :tag_id
@@ -25,7 +30,7 @@ module ActsAsTaggableOn
         if ActsAsTaggableOn.tags_counter
           tag.destroy if tag.reload.taggings_count.zero?
         else
-          tag.destroy if tag.reload.taggings.count.zero?
+          tag.destroy if tag.reload.taggings.none?
         end
       end
     end