acts-as-taggable-on 2.4.1 → 3.0.0

data/lib/acts_as_taggable_on/acts_as_taggable_on/compatibility.rb

@@ -31,4 +31,4 @@ module ActsAsTaggableOn::Compatibility
 
     [scope_opts, opts]
   end
-end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -104,14 +104,14 @@ module ActsAsTaggableOn::Taggable
             tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name #{like_operator} ?", t]) }.join(" OR ")
           end
 
-          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)})"
+          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, nil)})"
 
           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)}"
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name, nil)}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = #{quote_value(owned_by.id, nil)}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = #{quote_value(owned_by.class.base_class.to_s, nil)}"
           end
 
         elsif options.delete(:any)
@@ -134,11 +134,11 @@ module ActsAsTaggableOn::Taggable
 
           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}.taggable_type = #{quote_value(base_class.name, nil)}"
           tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
           # don't need to sanitize sql, map all ids and join with OR logic
-          conditions << tags.map { |t| "#{taggings_alias}.tag_id = #{t.id}" }.join(" OR ")
+          conditions << tags.map { |t| "#{taggings_alias}.tag_id = #{quote_value(t.id, nil)}" }.join(" OR ")
           select_clause = "DISTINCT #{table_name}.*" unless context and tag_types.one?
 
           if owned_by
@@ -160,8 +160,8 @@ module ActsAsTaggableOn::Taggable
             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}"
+                            " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name, nil)}" +
+                            " AND #{taggings_alias}.tag_id = #{quote_value(tag.id, nil)}"
 
             tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
@@ -183,7 +183,7 @@ module ActsAsTaggableOn::Taggable
         if options.delete(:match_all)
           joins << "LEFT OUTER 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}.taggable_type = #{quote_value(base_class.name, nil)}"
 
 
           group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
@@ -245,8 +245,13 @@ module ActsAsTaggableOn::Taggable
 
       def tag_list_cache_on(context)
         variable_name = "@#{context.to_s.singularize}_list"
-        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)))
+        if instance_variable_get(variable_name)
+          instance_variable_get(variable_name)
+        elsif cached_tag_list_on(context) && self.class.caching_tag_list_on?(context)
+          instance_variable_set(variable_name, ActsAsTaggableOn::TagList.from(cached_tag_list_on(context)))
+        else
+          instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
+        end
       end
 
       def tag_list_on(context)
@@ -324,6 +329,12 @@ module ActsAsTaggableOn::Taggable
         super(*args)
       end
 
+      ##
+      # Find existing tags or create non-existing tags
+      def load_tags(tag_list)
+        ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list)
+      end
+
       def save_tags
         tagging_contexts.each do |context|
           next unless tag_list_cache_set_on(context)
@@ -331,7 +342,7 @@ module ActsAsTaggableOn::Taggable
           tag_list = tag_list_cache_on(context).uniq
 
           # Find existing tags or create non-existing tags:
-          tags = ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list)
+          tags = load_tags(tag_list)
 
           # Tag objects for currently assigned tags
           current_tags = tags_on(context)
@@ -350,7 +361,7 @@ module ActsAsTaggableOn::Taggable
               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 = tags.map do |t|
                 new_tags.find { |n| n.name.downcase == t.name.downcase }
               end.compact
             end

data/lib/acts_as_taggable_on/engine.rb

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

data/lib/acts_as_taggable_on/tag.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
     include ActsAsTaggableOn::Utils
@@ -31,18 +32,29 @@ module ActsAsTaggableOn
 
     def self.named_any(list)
       if ActsAsTaggableOn.strict_case_match
-        where(list.map { |tag| sanitize_sql(["name = #{binary}?", tag.to_s.mb_chars]) }.join(" OR "))
+        clause = list.map { |tag|
+          sanitize_sql(["name = #{binary}?", as_8bit_ascii(tag)])
+        }.join(" OR ")
+        where(clause)
       else
-        where(list.map { |tag| sanitize_sql(["lower(name) = ?", tag.to_s.mb_chars.downcase]) }.join(" OR "))
+        clause = list.map { |tag|
+          lowercase_ascii_tag = as_8bit_ascii(tag).downcase
+          sanitize_sql(["lower(name) = ?", lowercase_ascii_tag])
+        }.join(" OR ")
+        where(clause)
       end
     end
 
     def self.named_like(name)
-      where(["name #{like_operator} ? ESCAPE '!'", "%#{escape_like(name)}%"])
+      clause = ["name #{like_operator} ? ESCAPE '!'", "%#{escape_like(name)}%"]
+      where(clause)
     end
 
     def self.named_like_any(list)
-      where(list.map { |tag| sanitize_sql(["name #{like_operator} ? ESCAPE '!'", "%#{escape_like(tag.to_s)}%"]) }.join(" OR "))
+      clause = list.map { |tag|
+        sanitize_sql(["name #{like_operator} ? ESCAPE '!'", "%#{escape_like(tag.to_s)}%"])
+      }.join(" OR ")
+      where(clause)
     end
 
     ### CLASS METHODS:
@@ -56,7 +68,7 @@ module ActsAsTaggableOn
     end
 
     def self.find_or_create_all_with_like_by_name(*list)
-      list = [list].flatten
+      list = Array(list).flatten
 
       return [] if list.empty?
 
@@ -64,7 +76,7 @@ module ActsAsTaggableOn
 
       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_tag = existing_tags.detect { |tag| comparable_name(tag.name) == comparable_tag_name }
 
         existing_tag || Tag.create(:name => tag_name)
       end
@@ -88,12 +100,20 @@ module ActsAsTaggableOn
       private
 
       def comparable_name(str)
-        str.mb_chars.downcase.to_s
+        as_8bit_ascii(str).downcase
       end
 
       def binary
         /mysql/ === ActiveRecord::Base.connection_config[:adapter] ? "BINARY " : nil
       end
+
+      def as_8bit_ascii(string)
+        if defined?(Encoding)
+          string.to_s.force_encoding('BINARY')
+        else
+          string.to_s.mb_chars
+        end
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/taggable.rb

@@ -25,7 +25,7 @@ module ActsAsTaggableOn
     def acts_as_ordered_taggable
       acts_as_ordered_taggable_on :tags
     end
-    
+
     ##
     # Make a model taggable on specified contexts.
     #
@@ -38,8 +38,8 @@ module ActsAsTaggableOn
     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
@@ -53,9 +53,9 @@ module ActsAsTaggableOn
     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
       #
@@ -78,7 +78,7 @@ module ActsAsTaggableOn
           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"

data/lib/acts_as_taggable_on/tagger.rb

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

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -12,4 +12,4 @@ module ActsAsTaggableOn
       end
     end
   end
-end
+end

data/lib/acts_as_taggable_on/version.rb

@@ -1,4 +1,4 @@
 module ActsAsTaggableOn
-  VERSION = '2.4.1'
+  VERSION = '3.0.0'
 end
 

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'spec_helper'
 
 describe "Acts As Taggable On" do
@@ -8,7 +9,7 @@ describe "Acts As Taggable On" do
   it "should provide a class method 'taggable?' that is false for untaggable models" do
     UntaggableModel.should_not be_taggable
   end
-  
+
   describe "Taggable Method Generation To Preserve Order" do
     before(:each) do
       clean_database!
@@ -46,7 +47,7 @@ describe "Acts As Taggable On" do
     it "should have all tag types" do
       @taggable.tag_types.should == [:tags, :languages, :skills, :needs, :offerings]
     end
-    
+
     it "should create a class attribute for preserve tag order" do
       @taggable.class.should respond_to(:preserve_tag_order?)
     end
@@ -54,7 +55,7 @@ describe "Acts As Taggable On" do
     it "should create an instance attribute for preserve tag order" do
       @taggable.should respond_to(:preserve_tag_order?)
     end
-    
+
     it "should respond 'false' to preserve_tag_order?" do
       @taggable.class.preserve_tag_order?.should be_false
     end
@@ -168,74 +169,6 @@ describe "Acts As Taggable On" do
     end
   end
 
-  describe 'Caching' do
-    before(:each) do
-      @taggable = CachedModel.new(:name => "Bob Jones")
-      @another_taggable = OtherCachedModel.new(:name => "John Smith")
-    end
-
-    it "should add saving of tag lists and cached tag lists to the instance" do
-      @taggable.should respond_to(:save_cached_tag_list)
-      @another_taggable.should respond_to(:save_cached_tag_list)
-
-      @taggable.should respond_to(:save_tags)
-    end
-
-    it "should add cached tag lists to the instance if cached column is not present" do
-      TaggableModel.new(:name => "Art Kram").should_not respond_to(:save_cached_tag_list)
-    end
-
-    it "should generate a cached column checker for each tag type" do
-      CachedModel.should respond_to(:caching_tag_list?)
-      OtherCachedModel.should respond_to(:caching_language_list?)
-    end
-
-    it 'should not have cached tags' do
-      @taggable.cached_tag_list.should be_blank
-      @another_taggable.cached_language_list.should be_blank
-    end
-
-    it 'should cache tags' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable.cached_tag_list.should == 'awesome, epic'
-
-      @another_taggable.update_attributes(:language_list => 'ruby, .net')
-      @another_taggable.cached_language_list.should == 'ruby, .net'
-    end
-
-    it 'should keep the cache' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable = CachedModel.find(@taggable)
-      @taggable.save!
-      @taggable.cached_tag_list.should == 'awesome, epic'
-    end
-
-    it 'should update the cache' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable.update_attributes(:tag_list => 'awesome')
-      @taggable.cached_tag_list.should == 'awesome'
-    end
-
-    it 'should remove the cache' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable.update_attributes(:tag_list => '')
-      @taggable.cached_tag_list.should be_blank
-    end
-
-    it 'should have a tag list' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable = CachedModel.find(@taggable.id)
-      @taggable.tag_list.sort.should == %w(awesome epic).sort
-    end
-
-    it 'should keep the tag list' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable = CachedModel.find(@taggable.id)
-      @taggable.save!
-      @taggable.tag_list.sort.should == %w(awesome epic).sort
-    end
-  end
-
   context 'when tagging context ends in an "s" when singular (ex. "status", "glass", etc.)' do
    describe 'caching' do
      before  { @taggable = OtherCachedModel.new(:name => "John Smith") }

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -4,7 +4,7 @@ describe "acts_as_tagger" do
   before(:each) do
     clean_database!
   end
-  
+
   describe "Tagger Method Generation" do
     before(:each) do
       @tagger = User.new
@@ -13,55 +13,55 @@ describe "acts_as_tagger" do
     it "should add #is_tagger? query method to the class-side" do
       User.should respond_to(:is_tagger?)
     end
-    
+
     it "should return true from the class-side #is_tagger?" do
       User.is_tagger?.should be_true
     end
-    
+
     it "should return false from the base #is_tagger?" do
       ActiveRecord::Base.is_tagger?.should be_false
     end
-    
+
     it "should add #is_tagger? query method to the singleton" do
       @tagger.should respond_to(:is_tagger?)
     end
-    
+
     it "should add #tag method on the instance-side" do
       @tagger.should respond_to(:tag)
     end
-    
+
     it "should generate an association for #owned_taggings and #owned_tags" do
       @tagger.should respond_to(:owned_taggings, :owned_tags)
     end
   end
-  
+
   describe "#tag" do
     context 'when called with a non-existent tag context' do
       before(:each) do
         @tagger = User.new
         @taggable = TaggableModel.new(:name=>"Richard Prior")
       end
-      
+
       it "should by default not throw an exception " do
         @taggable.tag_list_on(:foo).should be_empty
         lambda {
           @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo)
         }.should_not raise_error
       end
-      
+
       it 'should by default create the tag context on-the-fly' do
         @taggable.tag_list_on(:here_ond_now).should be_empty
         @tagger.tag(@taggable, :with=>'that', :on => :here_ond_now)
         @taggable.tag_list_on(:here_ond_now).should_not include('that')
         @taggable.all_tags_list_on(:here_ond_now).should include('that')
       end
-      
+
       it "should show all the tag list when both public and owned tags exist" do
         @taggable.tag_list = 'ruby, python'
         @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
         @taggable.all_tags_on(:tags).map(&:name).sort.should == %w(ruby python java lisp).sort
       end
-      
+
       it "should not add owned tags to the common list" do
         @taggable.tag_list = 'ruby, python'
         @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
@@ -69,12 +69,12 @@ describe "acts_as_tagger" do
         @tagger.tag(@taggable, :with => '', :on => :tags)
         @taggable.tag_list.should == %w(ruby python)
       end
-      
+
       it "should throw an exception when the default is over-ridden" do
         @taggable.tag_list_on(:foo_boo).should be_empty
         lambda {
           @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo_boo, :force=>false)
-        }.should raise_error        
+        }.should raise_error
       end
 
       it "should not create the tag context on-the-fly when the default is over-ridden" do
@@ -83,28 +83,28 @@ describe "acts_as_tagger" do
         @taggable.tag_list_on(:foo_boo).should be_empty
       end
     end
-    
+
     describe "when called by multiple tagger's" do
       before(:each) do
         @user_x = User.create(:name => "User X")
         @user_y = User.create(:name => "User Y")
         @taggable = TaggableModel.create(:name => 'acts_as_taggable_on', :tag_list => 'plugin')
-        
+
         @user_x.tag(@taggable, :with => 'ruby, rails',  :on => :tags)
         @user_y.tag(@taggable, :with => 'ruby, plugin', :on => :tags)
 
         @user_y.tag(@taggable, :with => '', :on => :tags)
         @user_y.tag(@taggable, :with => '', :on => :tags)
       end
-      
-      it "should delete owned tags" do        
+
+      it "should delete owned tags" do
         @user_y.owned_tags.should == []
       end
-      
+
       it "should not delete other taggers tags" do
         @user_x.owned_tags.should have(2).items
       end
-      
+
       it "should not delete original tags" do
         @taggable.all_tags_list_on(:tags).should include('plugin')
       end