make_taggable 0.6.3

data/lib/make_taggable/taggable/related.rb

@@ -0,0 +1,71 @@
+module MakeTaggable::Taggable
+  module Related
+    def self.included(base)
+      base.extend MakeTaggable::Taggable::Related::ClassMethods
+      base.initialize_make_taggable_related
+    end
+
+    module ClassMethods
+      def initialize_make_taggable_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 make_taggable(*args)
+        super(*args)
+        initialize_make_taggable_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} = #{MakeTaggable::Tagging.table_name}.taggable_id AND #{MakeTaggable::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{MakeTaggable::Tagging.table_name}.tag_id = #{MakeTaggable::Tag.table_name}.#{MakeTaggable::Tag.primary_key} AND #{MakeTaggable::Tag.table_name}.name IN (?) AND #{MakeTaggable::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} = #{MakeTaggable::Tagging.table_name}.taggable_id AND #{MakeTaggable::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{MakeTaggable::Tagging.table_name}.tag_id = #{MakeTaggable::Tag.table_name}.#{MakeTaggable::Tag.primary_key} AND #{MakeTaggable::Tag.table_name}.name IN (?) AND #{MakeTaggable::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 MakeTaggable::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(#{MakeTaggable::Tag.table_name}.#{MakeTaggable::Tag.primary_key}) AS count")
+        .from("#{klass.table_name}, #{MakeTaggable::Tag.table_name}, #{MakeTaggable::Tagging.table_name}")
+        .group(group_columns(klass))
+        .order("count DESC")
+        .where(conditions)
+    end
+  end
+end

data/lib/make_taggable/taggable/tag_list_type.rb

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

data/lib/make_taggable/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 MakeTaggable::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/make_taggable/taggable/tagged_with_query/all_tags_query.rb

@@ -0,0 +1,111 @@
+module MakeTaggable::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
+
+      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_#{MakeTaggable::Utils.sha_prefix(tag)}")
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module MakeTaggable::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]}" : ""
+
+      adjust_taggings_alias(
+        "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{MakeTaggable::Utils.sha_prefix(tag_list.join("_"))}"
+      )
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module MakeTaggable::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
+      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
+
+      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/make_taggable/taggable/tagged_with_query/query_base.rb

@@ -0,0 +1,61 @@
+module MakeTaggable::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 MakeTaggable.strict_case_match
+
+      if options[:wild].present?
+        matches_attribute.matches("%#{escaped_tag(tag)}%", "!")
+      else
+        matches_attribute.matches(escaped_tag(tag), "!")
+      end
+    end
+
+    def tags_match_type
+      matches_attribute = tag_arel_table[:name]
+      matches_attribute = matches_attribute.lower unless MakeTaggable.strict_case_match
+
+      if options[:wild].present?
+        matches_attribute.matches_any(tag_list.map { |tag| "%#{escaped_tag(tag)}%" }, "!")
+      else
+        matches_attribute.matches_any(tag_list.map { |tag| escaped_tag(tag).to_s }, "!")
+      end
+    end
+
+    def escaped_tag(tag)
+      tag = tag.downcase unless MakeTaggable.strict_case_match
+      MakeTaggable::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/make_taggable/tagger.rb

@@ -0,0 +1,89 @@
+module MakeTaggable
+  module Tagger
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      ##
+      # Make a model a tagger. This allows an instance of a model to claim ownership
+      # of tags.
+      #
+      # Example:
+      #   class User < ActiveRecord::Base
+      #     acts_as_tagger
+      #   end
+      def acts_as_tagger(opts = {})
+        class_eval do
+          owned_taggings_scope = opts.delete(:scope)
+
+          has_many :owned_taggings, owned_taggings_scope,
+            opts.merge(
+              as: :tagger,
+              class_name: "::MakeTaggable::Tagging",
+              dependent: :destroy
+            )
+
+          has_many :owned_tags, -> { distinct },
+            class_name: "::MakeTaggable::Tag",
+            source: :tag,
+            through: :owned_taggings
+        end
+
+        include MakeTaggable::Tagger::InstanceMethods
+        extend MakeTaggable::Tagger::SingletonMethods
+      end
+
+      def tagger?
+        false
+      end
+
+      def is_tagger?
+        tagger?
+      end
+    end
+
+    module InstanceMethods
+      ##
+      # Tag a taggable model with tags that are owned by the tagger.
+      #
+      # @param taggable The object that will be tagged
+      # @param [Hash] options An hash with options. Available options are:
+      #               * <tt>:with</tt> - The tags that you want to
+      #               * <tt>:on</tt>   - The context on which you want to tag
+      #
+      # Example:
+      #   @user.tag(@photo, :with => "paris, normandy", :on => :locations)
+      def tag(taggable, opts = {})
+        opts.reverse_merge!(force: true)
+        skip_save = opts.delete(:skip_save)
+        return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
+
+        fail "You need to specify a tag context using :on" unless opts.key?(:on)
+        fail "You need to specify some tags using :with" unless opts.key?(:with)
+        fail "No context :#{opts[:on]} defined in #{taggable.class}" unless opts[:force] || taggable.tag_types.include?(opts[:on])
+
+        taggable.set_owner_tag_list_on(self, opts[:on].to_s, opts[:with])
+        taggable.save unless skip_save
+      end
+
+      def tagger?
+        self.class.is_tagger?
+      end
+
+      def is_tagger?
+        tagger?
+      end
+    end
+
+    module SingletonMethods
+      def tagger?
+        true
+      end
+
+      def is_tagger?
+        tagger?
+      end
+    end
+  end
+end