acts-as-taggable-on 2.0.0.pre5 → 3.5.0

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.table_name}.#{klass.primary_key} != #{id} 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.rb

@@ -0,0 +1,102 @@
+module ActsAsTaggableOn
+  module Taggable
+
+    def taggable?
+      false
+    end
+
+    ##
+    # This is an alias for calling <tt>acts_as_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_taggable
+    #   end
+    def acts_as_taggable
+      acts_as_taggable_on :tags
+    end
+
+    ##
+    # This is an alias for calling <tt>acts_as_ordered_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_ordered_taggable
+    #   end
+    def acts_as_ordered_taggable
+      acts_as_ordered_taggable_on :tags
+    end
+
+    ##
+    # Make a model taggable on specified contexts.
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_taggable_on :languages, :skills
+    #   end
+    def acts_as_taggable_on(*tag_types)
+      taggable_on(false, tag_types)
+    end
+
+    ##
+    # Make a model taggable on specified contexts
+    # and preserves the order in which tags are created
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_ordered_taggable_on :languages, :skills
+    #   end
+    def acts_as_ordered_taggable_on(*tag_types)
+      taggable_on(true, tag_types)
+    end
+
+    private
+
+      # Make a model taggable on specified contexts
+      # and optionally preserves the order in which tags are created
+      #
+      # Separate methods used above for backwards compatibility
+      # so that the original acts_as_taggable_on method is unaffected
+      # as it's not possible to add another argument to the method
+      # without the tag_types being enclosed in square brackets
+      #
+      # NB: method overridden in core module in order to create tag type
+      #     associations and methods after this logic has executed
+      #
+    def taggable_on(preserve_tag_order, *tag_types)
+      tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
+
+      if taggable?
+        self.tag_types = (self.tag_types + tag_types).uniq
+        self.preserve_tag_order = preserve_tag_order
+      else
+        class_attribute :tag_types
+        self.tag_types = tag_types
+        class_attribute :preserve_tag_order
+        self.preserve_tag_order = preserve_tag_order
+
+        class_eval do
+          has_many :taggings, as: :taggable, dependent: :destroy, class_name: '::ActsAsTaggableOn::Tagging'
+          has_many :base_tags, through: :taggings, source: :tag, class_name: '::ActsAsTaggableOn::Tag'
+
+          def self.taggable?
+            true
+          end
+        end
+      end
+
+      # each of these add context-specific methods and must be
+      # called on each call of taggable_on
+      include Core
+      include Collection
+      include Cache
+      include Ownership
+      include Related
+      include Dirty
+    end
+  end
+end

data/lib/acts_as_taggable_on/tagger.rb

@@ -0,0 +1,88 @@
+module ActsAsTaggableOn
+  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
+          has_many_with_taggable_compatibility :owned_taggings,
+                                               opts.merge(
+                                                   as: :tagger,
+                                                   dependent: :destroy,
+                                                   class_name: '::ActsAsTaggableOn::Tagging'
+                                               )
+
+          has_many_with_taggable_compatibility :owned_tags,
+                                               through: :owned_taggings,
+                                               source: :tag,
+                                               class_name: '::ActsAsTaggableOn::Tag',
+                                               uniq: true
+        end
+
+        include ActsAsTaggableOn::Tagger::InstanceMethods
+        extend ActsAsTaggableOn::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

data/lib/acts_as_taggable_on/tagging.rb

@@ -1,23 +1,43 @@
-class Tagging < ActiveRecord::Base #:nodoc:
-  include ActsAsTaggableOn::ActiveRecord::Backports if ActiveRecord::VERSION::MAJOR < 3
+module ActsAsTaggableOn
+  class Tagging < ::ActiveRecord::Base #:nodoc:
+    #TODO, remove from 4.0.0
+    attr_accessible :tag,
+                    :tag_id,
+                    :context,
+                    :taggable,
+                    :taggable_type,
+                    :taggable_id,
+                    :tagger,
+                    :tagger_type,
+                    :tagger_id if defined?(ActiveModel::MassAssignmentSecurity)
 
-  attr_accessible :tag,
-                  :tag_id,
-                  :context,
-                  :taggable,
-                  :taggable_type,
-                  :taggable_id,
-                  :tagger,
-                  :tagger_type,
-                  :tagger_id
+    belongs_to :tag, class_name: '::ActsAsTaggableOn::Tag', counter_cache: ActsAsTaggableOn.tags_counter
+    belongs_to :taggable, polymorphic: true
+    belongs_to :tagger,   polymorphic: true
 
-  belongs_to :tag
-  belongs_to :taggable, :polymorphic => true
-  belongs_to :tagger,   :polymorphic => true
+    scope :owned_by, ->(owner) { where(tagger: owner) }
+    scope :not_owned, -> { where(tagger_id: nil, tagger_type: nil) }
 
-  validates_presence_of :context
-  validates_presence_of :tag_id
+    scope :by_contexts, ->(contexts = ['tags']) { where(context: contexts) }
+    scope :by_context, ->(context= 'tags') { by_contexts(context.to_s) }
 
-  validates_uniqueness_of :tag_id, :scope => [ :taggable_type, :taggable_id, :context, :tagger_id, :tagger_type ]
+    validates_presence_of :context
+    validates_presence_of :tag_id
 
-end
+    validates_uniqueness_of :tag_id, scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
+
+    after_destroy :remove_unused_tags
+
+    private
+
+    def remove_unused_tags
+      if ActsAsTaggableOn.remove_unused_tags
+        if ActsAsTaggableOn.tags_counter
+          tag.destroy if tag.reload.taggings_count.zero?
+        else
+          tag.destroy if tag.reload.taggings.count.zero?
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -1,17 +1,15 @@
-module TagsHelper
-
-  # See the README for an example using tag_cloud.
-  def tag_cloud(tags, classes)
-    tags = tags.all if tags.respond_to?(:all)
-
-    return [] if tags.empty?
-
-    max_count = tags.sort_by(&:count).last.count.to_f
-
-    tags.each do |tag|
-      index = ((tag.count / max_count) * (classes.size - 1)).round
-      yield tag, classes[index]
+module ActsAsTaggableOn
+  module TagsHelper
+    # See the wiki for an example using tag_cloud.
+    def tag_cloud(tags, classes)
+      return [] if tags.empty?
+
+      max_count = tags.sort_by(&:taggings_count).last.taggings_count.to_f
+
+      tags.each do |tag|
+        index = ((tag.taggings_count / max_count) * (classes.size - 1))
+        yield tag, classes[index.nan? ? 0 : index.round]
+      end
     end
   end
-
 end

data/lib/acts_as_taggable_on/utils.rb

@@ -0,0 +1,38 @@
+# This module is deprecated and will be removed in the incoming versions
+
+module ActsAsTaggableOn
+  module Utils
+    class << self
+      # Use ActsAsTaggableOn::Tag connection
+      def connection
+        ActsAsTaggableOn::Tag.connection
+      end
+
+      def using_postgresql?
+        connection && connection.adapter_name == 'PostgreSQL'
+      end
+
+      def using_mysql?
+        #We should probably use regex for mysql to support prehistoric adapters
+        connection && connection.adapter_name == 'Mysql2'
+      end
+
+      def sha_prefix(string)
+        Digest::SHA1.hexdigest(string)[0..6]
+      end
+
+      def active_record4?
+        ::ActiveRecord::VERSION::MAJOR == 4
+      end
+
+      def like_operator
+        using_postgresql? ? 'ILIKE' : 'LIKE'
+      end
+
+      # escape _ and % characters in strings, since these are wildcards in SQL.
+      def escape_like(str)
+        str.gsub(/[!%_]/) { |x| '!' + x }
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/version.rb

@@ -0,0 +1,4 @@
+module ActsAsTaggableOn
+  VERSION = '3.5.0'
+end
+

data/lib/acts_as_taggable_on.rb

@@ -0,0 +1,6 @@
+$stderr.puts <<EOF
+You are requiring 'acts_as_taggable_on' in the 'acts-as-taggable-on' gem.
+
+Please change your require to 'acts-as-taggable-on'.
+EOF
+require_relative 'acts-as-taggable-on'

data/lib/tasks/tags_collate_utf8.rake

@@ -0,0 +1,21 @@
+# These rake tasks are to be run by MySql users only, they fix the management of
+# binary-encoded strings for tag 'names'. Issues:
+# https://github.com/mbleigh/acts-as-taggable-on/issues/623
+
+namespace :acts_as_taggable_on_engine do
+
+  namespace :tag_names do
+
+    desc "Forcing collate of tag names to utf8_bin"
+    task :collate_bin => [:environment] do |t, args|
+      ActsAsTaggableOn::Configuration.apply_binary_collation(true)
+    end
+
+    desc "Forcing collate of tag names to utf8_general_ci"
+    task :collate_ci => [:environment] do |t, args|
+      ActsAsTaggableOn::Configuration.apply_binary_collation(false)
+    end
+
+  end
+
+end