acts-as-taggable-on 2.3.3 → 2.4.1

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -13,30 +13,33 @@ module ActsAsTaggableOn::Taggable
     end
 
     module ClassMethods
+
       def initialize_acts_as_taggable_on_core
+        include taggable_mixin
         tag_types.map(&:to_s).each do |tags_type|
           tag_type         = tags_type.to_s.singularize
           context_taggings = "#{tag_type}_taggings".to_sym
           context_tags     = tags_type.to_sym
-          taggings_order   = (preserve_tag_order? ? "#{ActsAsTaggableOn::Tagging.table_name}.id" : nil)
-          
+          taggings_order   = (preserve_tag_order? ? "#{ActsAsTaggableOn::Tagging.table_name}.id" : [])
+
           class_eval do
             # when preserving tag order, include order option so that for a 'tags' context
             # the associations tag_taggings & tags are always returned in created order
-            has_many context_taggings, :as => :taggable,
-                                       :dependent => :destroy,
-                                       :include => :tag,
-                                       :class_name => "ActsAsTaggableOn::Tagging",
-                                       :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_type],
-                                       :order => taggings_order
-                                       
-            has_many context_tags, :through => context_taggings,
-                                   :source => :tag,
-                                   :class_name => "ActsAsTaggableOn::Tag",
-                                   :order => taggings_order
+            has_many_with_compatibility context_taggings, :as => :taggable,
+                                        :dependent => :destroy,
+                                        :class_name => "ActsAsTaggableOn::Tagging",
+                                        :order => taggings_order,
+                                        :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.context = (?)", tags_type],
+                                        :include => :tag
+
+            has_many_with_compatibility context_tags, :through => context_taggings,
+                                        :source => :tag,
+                                        :class_name => "ActsAsTaggableOn::Tag",
+                                        :order => taggings_order
+
           end
 
-          class_eval %(
+          taggable_mixin.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{tag_type}_list
               tag_list_on('#{tags_type}')
             end
@@ -48,7 +51,7 @@ module ActsAsTaggableOn::Taggable
             def all_#{tags_type}_list
               all_tags_list_on('#{tags_type}')
             end
-          )
+          RUBY
         end
       end
 
@@ -56,7 +59,7 @@ module ActsAsTaggableOn::Taggable
         super(preserve_tag_order, *tag_types)
         initialize_acts_as_taggable_on_core
       end
-      
+
       # all column names are necessary for PostgreSQL group clause
       def grouped_column_names_for(object)
         object.column_names.map { |column| "#{object.table_name}.#{column}" }.join(", ")
@@ -80,12 +83,14 @@ module ActsAsTaggableOn::Taggable
       #   User.tagged_with("awesome", "cool", :owned_by => foo ) # Users that are tagged with just awesome and cool by 'foo'
       def tagged_with(tags, options = {})
         tag_list = ActsAsTaggableOn::TagList.from(tags)
-        empty_result = scoped(:conditions => "1 = 0")
+        empty_result = where("1 = 0")
 
         return empty_result if tag_list.empty?
 
         joins = []
         conditions = []
+        having = []
+        select_clause = []
 
         context = options.delete(:on)
         owned_by = options.delete(:owned_by)
@@ -101,15 +106,23 @@ module ActsAsTaggableOn::Taggable
 
           conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
 
+          if owned_by
+            joins <<  "JOIN #{ActsAsTaggableOn::Tagging.table_name}" +
+                      "  ON #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = #{owned_by.id}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = #{quote_value(owned_by.class.base_class.to_s)}"
+          end
+
         elsif options.delete(:any)
           # get tags, drop out if nothing returned (we need at least one)
-          if options.delete(:wild)
-            tags = ActsAsTaggableOn::Tag.named_like_any(tag_list)
+          tags = if options.delete(:wild)
+            ActsAsTaggableOn::Tag.named_like_any(tag_list)
           else
-            tags = ActsAsTaggableOn::Tag.named_any(tag_list)
+            ActsAsTaggableOn::Tag.named_any(tag_list)
           end
 
-          return scoped(:conditions => "1 = 0") unless tags.length > 0
+          return empty_result unless tags.length > 0
 
           # setup taggings alias so we can chain, ex: items_locations_taggings_awesome_cool_123
           # avoid ambiguous column name
@@ -128,29 +141,37 @@ module ActsAsTaggableOn::Taggable
           conditions << tags.map { |t| "#{taggings_alias}.tag_id = #{t.id}" }.join(" OR ")
           select_clause = "DISTINCT #{table_name}.*" unless context and tag_types.one?
 
-          joins << tagging_join
+          if owned_by
+              tagging_join << " AND " +
+                  sanitize_sql([
+                      "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
+                      owned_by.id,
+                      owned_by.class.base_class.to_s
+                  ])
+          end
 
+          joins << tagging_join
         else
           tags = ActsAsTaggableOn::Tag.named_any(tag_list)
+
           return empty_result unless tags.length == tag_list.length
 
           tags.each do |tag|
-
             taggings_alias = adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{sha_prefix(tag.name)}")
-
             tagging_join  = "JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
                             "  ON #{taggings_alias}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
                             " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}" +
                             " AND #{taggings_alias}.tag_id = #{tag.id}"
+
             tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
             if owned_by
                 tagging_join << " AND " +
-                    sanitize_sql([
-                        "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
-                        owned_by.id,
-                        owned_by.class.base_class.to_s
-                    ])
+                  sanitize_sql([
+                    "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
+                    owned_by.id,
+                    owned_by.class.base_class.to_s
+                  ])
             end
 
             joins << tagging_join
@@ -170,13 +191,13 @@ module ActsAsTaggableOn::Taggable
           having = "COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
         end
 
-        scoped(:select     => select_clause,
-               :joins      => joins.join(" "),
-               :group      => group,
-               :having     => having,
-               :conditions => conditions.join(" AND "),
-               :order      => options[:order],
-               :readonly   => false)
+        select(select_clause) \
+          .joins(joins.join(" ")) \
+          .where(conditions.join(" AND ")) \
+          .group(group) \
+          .having(having) \
+          .order(options[:order]) \
+          .readonly(false)
       end
 
       def is_taggable?
@@ -189,6 +210,10 @@ module ActsAsTaggableOn::Taggable
         end
         taggings_alias
       end
+
+      def taggable_mixin
+        @taggable_mixin ||= Module.new
+      end
     end
 
     module InstanceMethods
@@ -215,12 +240,13 @@ module ActsAsTaggableOn::Taggable
 
       def tag_list_cache_set_on(context)
         variable_name = "@#{context.to_s.singularize}_list"
-        !instance_variable_get(variable_name).nil?
+        instance_variable_defined?(variable_name) && !instance_variable_get(variable_name).nil?
       end
 
       def tag_list_cache_on(context)
         variable_name = "@#{context.to_s.singularize}_list"
-        instance_variable_get(variable_name) || instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
+        return instance_variable_get(variable_name) if instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
+        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
       end
 
       def tag_list_on(context)
@@ -230,7 +256,7 @@ module ActsAsTaggableOn::Taggable
 
       def all_tags_list_on(context)
         variable_name = "@all_#{context.to_s.singularize}_list"
-        return instance_variable_get(variable_name) if instance_variable_get(variable_name)
+        return instance_variable_get(variable_name) if instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
 
         instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(all_tags_on(context).map(&:name)).freeze)
       end
@@ -246,12 +272,10 @@ module ActsAsTaggableOn::Taggable
 
         if ActsAsTaggableOn::Tag.using_postgresql?
           group_columns = grouped_column_names_for(ActsAsTaggableOn::Tag)
-          scope = scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
+          scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
         else
-          scope = scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
-        end
-
-        scope.all
+          scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
+        end.to_a
       end
 
       ##
@@ -261,7 +285,7 @@ module ActsAsTaggableOn::Taggable
         # when preserving tag order, return tags in created order
         # if we added the order to the association this would always apply
         scope = scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id") if self.class.preserve_tag_order?
-        scope.all
+        scope
       end
 
       def set_tag_list_on(context, new_list)
@@ -303,7 +327,6 @@ module ActsAsTaggableOn::Taggable
       def save_tags
         tagging_contexts.each do |context|
           next unless tag_list_cache_set_on(context)
-
           # List of currently assigned tag names
           tag_list = tag_list_cache_on(context).uniq
 
@@ -315,13 +338,22 @@ module ActsAsTaggableOn::Taggable
 
           # Tag maintenance based on whether preserving the created order of tags
           if self.class.preserve_tag_order?
-            # First off order the array of tag objects to match the tag list
-            # rather than existing tags followed by new tags
-            tags = tag_list.map{|l| tags.detect{|t| t.name.downcase == l.downcase}}
-            # To preserve tags in the order in which they were added
-            # delete all current tags and create new tags if the content or order has changed
-            old_tags = (tags == current_tags ? [] : current_tags)
-            new_tags = (tags == current_tags ? [] : tags)
+            old_tags, new_tags = current_tags - tags, tags - current_tags
+
+            shared_tags = current_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 |= current_tags[index...current_tags.size]
+              new_tags |= current_tags[index...current_tags.size] & shared_tags
+
+              # Order the array of tag objects to match the tag list
+              new_tags = tags.map do |t| 
+                new_tags.find { |n| n.name.downcase == t.name.downcase }
+              end.compact
+            end
           else
             # Delete discarded tags and create new tags
             old_tags = current_tags - tags
@@ -330,8 +362,7 @@ module ActsAsTaggableOn::Taggable
 
           # Find taggings to remove:
           if old_tags.present?
-            old_taggings = taggings.where(:tagger_type => nil, :tagger_id => nil,
-                                          :context => context.to_s, :tag_id => old_tags).all
+            old_taggings = taggings.where(:tagger_type => nil, :tagger_id => nil, :context => context.to_s, :tag_id => old_tags)
           end
 
           # Destroy old taggings:

data/lib/acts_as_taggable_on/acts_as_taggable_on/dirty.rb

@@ -12,7 +12,7 @@ module ActsAsTaggableOn::Taggable
           tag_type         = tags_type.to_s.singularize
           context_tags     = tags_type.to_sym
 
-          class_eval %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{tag_type}_list_changed?
               changed_attributes.include?("#{tag_type}_list")
             end
@@ -28,10 +28,10 @@ module ActsAsTaggableOn::Taggable
             def #{tag_type}_list_changes
               [changed_attributes['#{tag_type}_list'], __send__('#{tag_type}_list')] if changed_attributes.include?("#{tag_type}_list")
             end
-          )
+          RUBY
 
         end
       end
     end
   end
-end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -19,11 +19,11 @@ module ActsAsTaggableOn::Taggable
       
       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      
-          )
+          RUBY
         end        
       end
     end
@@ -37,22 +37,25 @@ module ActsAsTaggableOn::Taggable
                                      #{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
+
         # when preserving tag order, return tags in created order
         # if we added the order to the association this would always apply
-        scope = scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id") if self.class.preserve_tag_order?
-        scope.all
+        if self.class.preserve_tag_order?
+          scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id")
+        else 
+          scope
+        end
       end
 
       def cached_owned_tag_list_on(context)
         variable_name = "@owned_#{context}_list"
-        cache = instance_variable_get(variable_name) || instance_variable_set(variable_name, {})
+        cache = (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.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
         
         cache[owner] ||= ActsAsTaggableOn::TagList.new(*owner_tags_on(owner, context).map(&:name))
       end
@@ -61,7 +64,6 @@ module ActsAsTaggableOn::Taggable
         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] = ActsAsTaggableOn::TagList.from(new_list)
       end
@@ -86,13 +88,20 @@ module ActsAsTaggableOn::Taggable
                
             # Tag maintenance based on whether preserving the created order of tags
             if self.class.preserve_tag_order?
-              # First off order the array of tag objects to match the tag list
-              # rather than existing tags followed by new tags
-              tags = tag_list.uniq.map{|s| tags.detect{|t| t.name.downcase == s.downcase}}
-              # To preserve tags in the order in which they were added
-              # delete all owned tags and create new tags if the content or order has changed
-              old_tags = (tags == owned_tags ? [] : owned_tags)
-              new_tags = (tags == owned_tags ? [] : tags)
+              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
@@ -104,7 +113,7 @@ module ActsAsTaggableOn::Taggable
             if old_tags.present?
               old_taggings = 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).all
+                                                             :tag_id => old_tags, :context => context)
             end
           
             # Destroy old taggings:

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -9,7 +9,7 @@ module ActsAsTaggableOn::Taggable
     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
@@ -18,11 +18,11 @@ module ActsAsTaggableOn::Taggable
             def find_related_#{tag_type}_for(klass, options = {})
               related_tags_for('#{tag_type}', klass, options)
             end
-          )
+          RUBY
         end
 
         unless tag_types.empty?
-          class_eval %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def find_matching_contexts(search_context, result_context, options = {})
               matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
             end
@@ -30,7 +30,7 @@ module ActsAsTaggableOn::Taggable
             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
-          )
+          RUBY
         end
       end
 
@@ -44,29 +44,40 @@ module ActsAsTaggableOn::Taggable
       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}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
-
-        group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
-
-        klass.scoped({ :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}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' 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],
-                       :group      => group_columns,
-                       :order      => "count DESC" }.update(options))
+        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}") \
+             .where(["#{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.to_s}' 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]) \
+             .group(group_columns(klass)) \
+             .order("count DESC")
       end
 
       def related_tags_for(context, klass, options = {})
-        tags_to_find = tags_on(context).collect { |t| t.name }
+				tags_to_ignore = Array.wrap(options.delete(:ignore)).map(&:to_s) || []
+        tags_to_find = tags_on(context).collect { |t| t.name }.reject { |t| tags_to_ignore.include? t }
 
-        exclude_self = "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
+        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}") \
+             .where(["#{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.to_s}' 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]) \
+             .group(group_columns(klass)) \
+             .order("count DESC")
+      end
 
-        group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
+      private
+      
+      def exclude_self(klass, id)
+        if [self.class.base_class, self.class].include? klass
+          "#{klass.table_name}.#{klass.primary_key} != #{id} AND" 
+        else
+          nil
+        end
+      end
 
-        klass.scoped({ :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}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' 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],
-                       :group      => group_columns,
-                       :order      => "count DESC" }.update(options))
+      def group_columns(klass)
+        if ActsAsTaggableOn::Tag.using_postgresql? 
+          grouped_column_names_for(klass)
+        else
+          "#{klass.table_name}.#{klass.primary_key}"
+        end
       end
     end
   end

data/lib/acts_as_taggable_on/tag.rb

@@ -2,7 +2,7 @@ module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
     include ActsAsTaggableOn::Utils
 
-    attr_accessible :name
+    attr_accessible :name if defined?(ActiveModel::MassAssignmentSecurity)
 
     ### ASSOCIATIONS:
 
@@ -11,17 +11,30 @@ module ActsAsTaggableOn
     ### VALIDATIONS:
 
     validates_presence_of :name
-    validates_uniqueness_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)
-      where(["lower(name) = ?", name.downcase])
+      if ActsAsTaggableOn.strict_case_match
+        where(["name = #{binary}?", name])
+      else
+        where(["lower(name) = ?", name.downcase])
+      end
     end
 
     def self.named_any(list)
-      where(list.map { |tag| sanitize_sql(["lower(name) = ?", tag.to_s.mb_chars.downcase]) }.join(" OR "))
+      if ActsAsTaggableOn.strict_case_match
+        where(list.map { |tag| sanitize_sql(["name = #{binary}?", tag.to_s.mb_chars]) }.join(" OR "))
+      else
+        where(list.map { |tag| sanitize_sql(["lower(name) = ?", tag.to_s.mb_chars.downcase]) }.join(" OR "))
+      end
     end
 
     def self.named_like(name)
@@ -35,7 +48,11 @@ module ActsAsTaggableOn
     ### CLASS METHODS:
 
     def self.find_or_create_with_like_by_name(name)
-      named_like(name).first || create(: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)
@@ -43,14 +60,14 @@ module ActsAsTaggableOn
 
       return [] if list.empty?
 
-      existing_tags = Tag.named_any(list).all
-      new_tag_names = list.reject do |name|
-                        name = comparable_name(name)
-                        existing_tags.any? { |tag| comparable_name(tag.name) == name }
-                      end
-      created_tags  = new_tag_names.map { |name| Tag.create(:name => name) }
+      existing_tags = Tag.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 }
 
-      existing_tags + created_tags
+        existing_tag || Tag.create(:name => tag_name)
+      end
     end
 
     ### INSTANCE METHODS:
@@ -69,9 +86,14 @@ module ActsAsTaggableOn
 
     class << self
       private
-        def comparable_name(str)
-          str.mb_chars.downcase.to_s
-        end
+
+      def comparable_name(str)
+        str.mb_chars.downcase.to_s
+      end
+
+      def binary
+        /mysql/ === ActiveRecord::Base.connection_config[:adapter] ? "BINARY " : nil
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/tag_list.rb

@@ -58,7 +58,7 @@ module ActsAsTaggableOn
     end
 
     ##
-    # Transform the tag_list into a tag string suitable for edting in a form.
+    # Transform the tag_list into a tag string suitable for editing in a form.
     # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
     #
     # Example:
@@ -81,7 +81,7 @@ module ActsAsTaggableOn
     def clean!
       reject!(&:blank?)
       map!(&:strip)
-      map!(&:downcase) if ActsAsTaggableOn.force_lowercase
+      map!{ |tag| tag.mb_chars.downcase.to_s } if ActsAsTaggableOn.force_lowercase
       map!(&:parameterize) if ActsAsTaggableOn.force_parameterize
 
       uniq!

data/lib/acts_as_taggable_on/taggable.rb

@@ -80,7 +80,7 @@ module ActsAsTaggableOn
           self.preserve_tag_order = preserve_tag_order
         
           class_eval do
-            has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging"
+            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?
@@ -88,14 +88,17 @@ module ActsAsTaggableOn
             end
 
             include ActsAsTaggableOn::Utils
-            include ActsAsTaggableOn::Taggable::Core
-            include ActsAsTaggableOn::Taggable::Collection
-            include ActsAsTaggableOn::Taggable::Cache
-            include ActsAsTaggableOn::Taggable::Ownership
-            include ActsAsTaggableOn::Taggable::Related
-            include ActsAsTaggableOn::Taggable::Dirty
           end
         end
+
+        # each of these add context-specific methods and must be
+        # called on each call of taggable_on
+        include ActsAsTaggableOn::Taggable::Core
+        include ActsAsTaggableOn::Taggable::Collection
+        include ActsAsTaggableOn::Taggable::Cache
+        include ActsAsTaggableOn::Taggable::Ownership
+        include ActsAsTaggableOn::Taggable::Related
+        include ActsAsTaggableOn::Taggable::Dirty
       end
 
   end

data/lib/acts_as_taggable_on/tagger.rb

@@ -15,9 +15,18 @@ module ActsAsTaggableOn
       #   end
       def acts_as_tagger(opts={})
         class_eval do
-          has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy,
-                                               :include => :tag, :class_name => "ActsAsTaggableOn::Tagging")
-          has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true, :class_name => "ActsAsTaggableOn::Tag"
+          has_many_with_compatibility :owned_taggings, 
+            opts.merge(
+              :as => :tagger, 
+              :dependent => :destroy,
+              :class_name => "ActsAsTaggableOn::Tagging"
+            )
+
+          has_many_with_compatibility :owned_tags, 
+                                      :through => :owned_taggings, 
+                                      :source => :tag, 
+                                      :class_name => "ActsAsTaggableOn::Tag", 
+                                      :uniq => true
         end
 
         include ActsAsTaggableOn::Tagger::InstanceMethods