acts-as-taggable-on 2.0.0 → 3.2.2

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -1,101 +1,125 @@
 module ActsAsTaggableOn::Taggable
   module Ownership
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Ownership::InstanceMethods
       base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
-     
+
       base.class_eval do
-        after_save :save_owned_tags    
+        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      
+
+      def initialize_acts_as_taggable_on_ownership
         tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{tag_type}_from(owner)
               owner_tag_list_on(owner, '#{tag_type}')
-            end      
-          )
-        end        
+            end
+          RUBY
+        end
       end
     end
-    
-    module InstanceMethods
-      def owner_tags_on(owner, context)
-        base_tags.where([%(#{Tagging.table_name}.context = ? AND
-                           #{Tagging.table_name}.tagger_id = ? AND
-                           #{Tagging.table_name}.tagger_type = ?), context.to_s, owner.id, owner.class.to_s]).all
-      end
 
-      def cached_owned_tag_list_on(context)
-        variable_name = "@owned_#{context}_list"
-        cache = instance_variable_get(variable_name) || instance_variable_set(variable_name, {})
+    def owner_tags_on(owner, context)
+      if owner.nil?
+        scope = base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ?), context.to_s])
+      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])
       end
-      
-      def owner_tag_list_on(owner, context)
-        add_custom_context(context)
-
-        cache = cached_owned_tag_list_on(context)
-        cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
-        
-        cache[owner] ||= 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.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
-
-        cache[owner] = TagList.from(new_list)
+
+      # 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
-      
-      def reload
-        self.class.tag_types.each do |context|
-          instance_variable_set("@owned_#{context}_list", nil)
-        end
-      
-        super
+    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::TagList.from(new_list)
+    end
+
+    def reload(*args)
+      self.class.tag_types.each do |context|
+        instance_variable_set("@owned_#{context}_list", nil)
       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:
-            tag_list = Tag.find_or_create_all_with_like_by_name(tag_list.uniq)            
-
-            owned_tags = owner_tags_on(owner, context)              
-            old_tags   = owned_tags - tag_list
-            new_tags   = tag_list   - owned_tags
-          
-            # Find all taggings that belong to the taggable (self), are owned by the owner, 
-            # have the correct context, and are removed from the list.
-            old_taggings = Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
-                                         :tagger_type => owner.class.to_s, :tagger_id => owner.id,
-                                         :tag_id => old_tags, :context => context).all
-          
-            if old_taggings.present?
-              # Destroy old taggings:
-              Tagging.destroy_all(:id => old_taggings.map(&:id))
-            end
 
-            # Create new taggings:
-            new_tags.each do |tag|
-              taggings.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
+      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)
+
+          # 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.destroy_all(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) 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
-        
-        true
       end
+
+      true
     end
   end
-end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -1,14 +1,14 @@
 module ActsAsTaggableOn::Taggable
   module Related
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Related::InstanceMethods
       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 %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def find_related_#{tag_type}(options = {})
               related_tags_for('#{tag_type}', self.class, options)
             end
@@ -17,48 +17,55 @@ module ActsAsTaggableOn::Taggable
             def find_related_#{tag_type}_for(klass, options = {})
               related_tags_for('#{tag_type}', klass, 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
-          )
-        end        
+          RUBY
+        end
       end
-      
+
       def acts_as_taggable_on(*args)
         super(*args)
         initialize_acts_as_taggable_on_related
       end
     end
-    
-    module InstanceMethods
-      def matching_contexts_for(search_context, result_context, klass, options = {})
-        tags_to_find = tags_on(search_context).collect { |t| t.name }
 
-        exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
-        
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{Tag.table_name}.id) AS count",
-                       :from       => "#{klass.table_name}, #{Tag.table_name}, #{Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{Tagging.table_name}.taggable_id AND #{Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND #{Tag.table_name}.name IN (?) AND #{Tagging.table_name}.context = ?", tags_to_find, result_context],
-                       :group      => grouped_column_names_for(klass),
-                       :order      => "count DESC" }.update(options))
-      end
-      
-      def related_tags_for(context, klass, options = {})
-        tags_to_find = tags_on(context).collect { |t| t.name }
+    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.delete(: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 (?)", tags_to_find])
+    end
 
-        exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
+    private
 
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{Tag.table_name}.id) AS count",
-                       :from       => "#{klass.table_name}, #{Tag.table_name}, #{Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{Tagging.table_name}.taggable_id AND #{Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND #{Tag.table_name}.name IN (?)", tags_to_find],
-                       :group      => grouped_column_names_for(klass),
-                       :order      => "count DESC" }.update(options))
+    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
+end

data/lib/acts_as_taggable_on/engine.rb

@@ -0,0 +1,5 @@
+require 'rails/engine'
+module ActsAsTaggableOn
+  class Engine < Rails::Engine
+  end
+end

data/lib/acts_as_taggable_on/tag.rb

@@ -1,65 +1,135 @@
-class Tag < ActiveRecord::Base
-  include ActsAsTaggableOn::ActiveRecord::Backports if ActiveRecord::VERSION::MAJOR < 3
-  
-  attr_accessible :name
-
-  ### ASSOCIATIONS:
-
-  has_many :taggings, :dependent => :destroy
-
-  ### VALIDATIONS:
-
-  validates_presence_of :name
-  validates_uniqueness_of :name
-
-  ### SCOPES:
-
-  def self.named(name)
-    where(["name LIKE ?", name])
-  end
-  
-  def self.named_any(list)
-    where(list.map { |tag| sanitize_sql(["name LIKE ?", tag.to_s]) }.join(" OR "))
-  end
-  
-  def self.named_like(name)
-    where(["name LIKE ?", "%#{name}%"])
-  end
-
-  def self.named_like_any(list)
-    where(list.map { |tag| sanitize_sql(["name LIKE ?", "%#{tag.to_s}%"]) }.join(" OR "))
-  end
-
-  ### CLASS METHODS:
-
-  def self.find_or_create_with_like_by_name(name)
-    named_like(name).first || create(:name => name)
+# coding: utf-8
+module ActsAsTaggableOn
+  class Tag < ::ActiveRecord::Base
+
+    attr_accessible :name if defined?(ActiveModel::MassAssignmentSecurity)
+
+    ### ASSOCIATIONS:
+
+    has_many :taggings, dependent: :destroy, class_name: 'ActsAsTaggableOn::Tagging'
+
+    ### VALIDATIONS:
+
+    validates_presence_of :name
+    validates_uniqueness_of :name, if: :validates_name_uniqueness?
+    validates_length_of :name, maximum: 255
+
+    # monkey patch this method if don't need name uniqueness validation
+    def validates_name_uniqueness?
+      true
+    end
+
+    ### SCOPES:
+
+    def self.named(name)
+      if ActsAsTaggableOn.strict_case_match
+        where(["name = #{binary}?", as_8bit_ascii(name)])
+      else
+        where(['LOWER(name) = LOWER(?)', as_8bit_ascii(unicode_downcase(name))])
+      end
+    end
+
+    def self.named_any(list)
+      if ActsAsTaggableOn.strict_case_match
+        clause = list.map { |tag|
+          sanitize_sql(["name = #{binary}?", as_8bit_ascii(tag)])
+        }.join(' OR ')
+        where(clause)
+      else
+        clause = list.map { |tag|
+          sanitize_sql(['LOWER(name) = LOWER(?)', as_8bit_ascii(unicode_downcase(tag))])
+        }.join(' OR ')
+        where(clause)
+      end
+    end
+
+    def self.named_like(name)
+      clause = ["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'", "%#{ActsAsTaggableOn::Utils.escape_like(name)}%"]
+      where(clause)
+    end
+
+    def self.named_like_any(list)
+      clause = list.map { |tag|
+        sanitize_sql(["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'", "%#{ActsAsTaggableOn::Utils.escape_like(tag.to_s)}%"])
+      }.join(' OR ')
+      where(clause)
+    end
+
+    ### CLASS METHODS:
+
+    def self.find_or_create_with_like_by_name(name)
+      if ActsAsTaggableOn.strict_case_match
+        self.find_or_create_all_with_like_by_name([name]).first
+      else
+        named_like(name).first || create(name: name)
+      end
+    end
+
+    def self.find_or_create_all_with_like_by_name(*list)
+      list = Array(list).flatten
+
+      return [] if list.empty?
+
+      existing_tags = named_any(list)
+
+      list.map do |tag_name|
+        comparable_tag_name = comparable_name(tag_name)
+        existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
+        begin
+          existing_tag || create(name: tag_name)
+        rescue ActiveRecord::RecordNotUnique
+          # Postgres aborts the current transaction with
+          # PG::InFailedSqlTransaction: ERROR:  current transaction is aborted, commands ignored until end of transaction block
+          # so we have to rollback this transaction
+          raise DuplicateTagError.new("'#{tag_name}' has already been taken")
+        end
+      end
+    end
+
+    ### INSTANCE METHODS:
+
+    def ==(object)
+      super || (object.is_a?(Tag) && name == object.name)
+    end
+
+    def to_s
+      name
+    end
+
+    def count
+      read_attribute(:count).to_i
+    end
+
+    class << self
+      private
+
+      def comparable_name(str)
+        if ActsAsTaggableOn.strict_case_match
+          str
+        else
+          unicode_downcase(str.to_s)
+        end
+      end
+
+      def binary
+        ActsAsTaggableOn::Utils.using_mysql? ? 'BINARY ' : nil
+      end
+
+      def unicode_downcase(string)
+        if ActiveSupport::Multibyte::Unicode.respond_to?(:downcase)
+          ActiveSupport::Multibyte::Unicode.downcase(string)
+        else
+          ActiveSupport::Multibyte::Chars.new(string).downcase.to_s
+        end
+      end
+
+      def as_8bit_ascii(string)
+        if defined?(Encoding)
+          string.to_s.dup.force_encoding('BINARY')
+        else
+          string.to_s.mb_chars
+        end
+      end
+    end
   end
-
-  def self.find_or_create_all_with_like_by_name(*list)
-    list = [list].flatten
-
-    return [] if list.empty?
-
-    existing_tags = Tag.named_any(list).all
-    new_tag_names = list.reject { |name| existing_tags.any? { |tag| tag.name.mb_chars.downcase == name.mb_chars.downcase } }
-    created_tags  = new_tag_names.map { |name| Tag.create(:name => name) }
-
-    existing_tags + created_tags
-  end
-
-  ### INSTANCE METHODS:
-
-  def ==(object)
-    super || (object.is_a?(Tag) && name == object.name)
-  end
-
-  def to_s
-    name
-  end
-
-  def count
-    read_attribute(:count).to_i
-  end
-
 end