sb-acts-as-taggable-on 6.5.0

data/lib/acts_as_taggable_on/taggable/ownership.rb

@@ -0,0 +1,136 @@
+module ActsAsTaggableOn::Taggable
+  module Ownership
+    def self.included(base)
+      base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
+
+      base.class_eval do
+        after_save :save_owned_tags
+      end
+
+      base.initialize_acts_as_taggable_on_ownership
+    end
+
+    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
+        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
+          }
+        )
+      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
+
+    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)
+
+      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
+
+    def reload(*args)
+      self.class.tag_types.each do |context|
+        instance_variable_set("@owned_#{context}_list", nil)
+      end
+
+      super(*args)
+    end
+
+    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)
+
+          # Tag objects for owned tags
+          owned_tags = owner_tags_on(owner, context).to_a
+
+          # 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
+
+            shared_tags = owned_tags & tags
+
+            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] }
+
+              # 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 { |t| new_tags.find { |n| n.name.downcase == t.name.downcase } }.compact
+            end
+          else
+            # Delete discarded tags and create new tags
+            old_tags = owned_tags - tags
+            new_tags = tags - owned_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?
+
+          # 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
+
+      true
+    end
+  end
+end

data/lib/acts_as_taggable_on/taggable/related.rb

@@ -0,0 +1,71 @@
+module ActsAsTaggableOn::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
+            def find_related_#{tag_type}(options = {})
+              related_tags_for('#{tag_type}', self.class, options)
+            end
+            alias_method :find_related_on_#{tag_type}, :find_related_#{tag_type}
+
+            def find_related_#{tag_type}_for(klass, options = {})
+              related_tags_for('#{tag_type}', klass, options)
+            end
+          RUBY
+        end
+      end
+
+      def acts_as_taggable_on(*args)
+        super(*args)
+        initialize_acts_as_taggable_on_related
+      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_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 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
+
+    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 group_columns(klass)
+      if ActsAsTaggableOn::Utils.using_postgresql?
+        grouped_column_names_for(klass)
+      else
+        "#{klass.table_name}.#{klass.primary_key}"
+      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)
+    end
+  end
+end

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