acts-as-taggable-on 2.3.3 → 2.4.0.beta

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -14,6 +14,7 @@ module ActsAsTaggableOn::Taggable
 
     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
@@ -36,7 +37,7 @@ module ActsAsTaggableOn::Taggable
                                    :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 +49,7 @@ module ActsAsTaggableOn::Taggable
             def all_#{tags_type}_list
               all_tags_list_on('#{tags_type}')
             end
-          )
+          RUBY
         end
       end
 
@@ -189,6 +190,10 @@ module ActsAsTaggableOn::Taggable
         end
         taggings_alias
       end
+
+      def taggable_mixin
+        @taggable_mixin ||= Module.new
+      end
     end
 
     module InstanceMethods
@@ -215,12 +220,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 +236,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

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,7 +28,7 @@ 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

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
@@ -45,7 +45,7 @@ module ActsAsTaggableOn::Taggable
 
       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)

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
 
@@ -56,7 +56,9 @@ module ActsAsTaggableOn::Taggable
       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)) || []
+				tags_to_ignore.map! { |t| t.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
 

data/lib/acts_as_taggable_on/tag.rb

@@ -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)
@@ -45,9 +62,9 @@ module ActsAsTaggableOn
 
       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
+        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 + created_tags
@@ -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/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -185,6 +185,39 @@ describe "Acts As Taggable On" do
       taggable1.find_related_tags.should_not include(taggable1)
     end
 
+		context "Ignored Tags" do
+			let(:taggable1) { TaggableModel.create!(:name => "Taggable 1") }
+			let(:taggable2) { TaggableModel.create!(:name => "Taggable 2") }
+			let(:taggable3) { TaggableModel.create!(:name => "Taggable 3") }
+			before(:each) do
+				taggable1.tag_list = "one, two, four"
+				taggable1.save
+
+				taggable2.tag_list = "two, three"
+				taggable2.save
+
+				taggable3.tag_list = "one, three"
+				taggable3.save
+			end
+			it "should not include ignored tags in related search" do
+				taggable1.find_related_tags(:ignore => 'two').should_not include(taggable2)
+				taggable1.find_related_tags(:ignore => 'two').should include(taggable3)
+			end
+
+			it "should accept array of ignored tags" do
+				taggable4 = TaggableModel.create!(:name => "Taggable 4")
+				taggable4.tag_list = "four"
+				taggable4.save
+
+				taggable1.find_related_tags(:ignore => ['two', 'four']).should_not include(taggable2)
+				taggable1.find_related_tags(:ignore => ['two', 'four']).should_not include(taggable4)
+			end
+
+			it "should accept symbols as ignored tags" do
+				taggable1.find_related_tags(:ignore => :two).should_not include(taggable2)
+			end
+		end
+
     context "Inherited Models" do
       before do
         @taggable1 = InheritingTaggableModel.create!(:name => "InheritingTaggable 1")

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -84,8 +84,8 @@ describe ActsAsTaggableOn::TagList do
     it "should lowercase if force_lowercase is set to true" do
       ActsAsTaggableOn.force_lowercase = true
 
-      tag_list = ActsAsTaggableOn::TagList.new("aweSomE","RaDicaL")
-      tag_list.to_s.should == "awesome, radical"
+      tag_list = ActsAsTaggableOn::TagList.new("aweSomE","RaDicaL","Entrée")
+      tag_list.to_s.should == "awesome, radical, entrée"
 
       ActsAsTaggableOn.force_lowercase = false
     end

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -150,4 +150,63 @@ describe ActsAsTaggableOn::Tag do
 
   end
 
-end
+  describe "when using strict_case_match" do
+    before do
+      ActsAsTaggableOn.strict_case_match = true
+      @tag.name = "awesome"
+      @tag.save!
+    end
+
+    after do
+      ActsAsTaggableOn.strict_case_match = false
+    end
+
+    it "should find by name" do
+      ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("awesome").should == @tag
+    end
+
+    it "should find by name case sensitively" do
+      expect {
+        ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("AWESOME")
+      }.to change(ActsAsTaggableOn::Tag, :count)
+
+      ActsAsTaggableOn::Tag.last.name.should == "AWESOME"
+    end
+
+    it "should have a named_scope named(something) that matches exactly" do
+      uppercase_tag = ActsAsTaggableOn::Tag.create(:name => "Cool")
+      @tag.name     = "cool"
+      @tag.save!
+
+      ActsAsTaggableOn::Tag.named('cool').should include(@tag)
+      ActsAsTaggableOn::Tag.named('cool').should_not include(uppercase_tag)
+    end
+  end
+
+  describe "name uniqeness validation" do
+    let(:duplicate_tag) { ActsAsTaggableOn::Tag.new(:name => 'ror') }
+
+    before { ActsAsTaggableOn::Tag.create(:name => 'ror') }
+
+    context "when don't need unique names" do
+      it "should not run uniqueness validation" do
+        duplicate_tag.stub(:validates_name_uniqueness?).and_return(false)
+        duplicate_tag.save
+        duplicate_tag.should be_persisted
+      end  
+    end
+
+    context "when do need unique names" do
+      it "should run uniqueness validation" do
+        duplicate_tag.should_not be_valid        
+      end
+
+      it "add error to name" do
+        duplicate_tag.save
+
+        duplicate_tag.should have(1).errors
+        duplicate_tag.errors.messages[:name].should include('has already been taken')
+      end
+    end
+  end
+end

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -134,6 +134,16 @@ describe "Taggable" do
     @taggable.tag_counts_on(:tags).length.should == 2
   end
 
+  it "should have tags_on" do
+    TaggableModel.tags_on(:tags).all.should be_empty
+
+    @taggable.tag_list = ["awesome", "epic"]
+    @taggable.save
+
+    TaggableModel.tags_on(:tags).length.should == 2
+    @taggable.tags_on(:tags).length.should == 2
+  end
+
   it "should return [] right after create" do
     blank_taggable = TaggableModel.new(:name => "Bob Jones")
     blank_taggable.tag_list.should == []
@@ -242,6 +252,15 @@ describe "Taggable" do
     TaggableModel.all_tag_counts(:order => 'tags.id').first.count.should == 3 # ruby
   end
 
+  it "should be able to get all tags on model as whole" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
+    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+
+    TaggableModel.all_tags.all.should_not be_empty
+    TaggableModel.all_tags(:order => 'tags.id').first.name.should == "ruby"
+  end
+
   it "should be able to use named scopes to chain tag finds by any tags by context" do
     bob   = TaggableModel.create(:name => "Bob",   :need_list => "rails", :offering_list => "c++")
     frank = TaggableModel.create(:name => "Frank", :need_list => "css",   :offering_list => "css")
@@ -273,6 +292,14 @@ describe "Taggable" do
     TaggableModel.tagged_with("ruby").all_tag_counts(:order => 'tags.id').first.count.should == 3 # ruby
   end
 
+  it "should be able to get all scoped tags" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
+    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+
+    TaggableModel.tagged_with("ruby").all_tags(:order => 'tags.id').first.name.should == "ruby"
+  end
+
   it 'should only return tag counts for the available scope' do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
@@ -288,6 +315,21 @@ describe "Taggable" do
     TaggableModel.tagged_with('rails').scoped(:joins => [:untaggable_models]).all_tag_counts.should have(2).items
   end
 
+  it 'should only return tags for the available scope' do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
+    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby, java")
+
+    TaggableModel.tagged_with('rails').all_tags.should have(3).items
+    TaggableModel.tagged_with('rails').all_tags.any? { |tag| tag.name == 'java' }.should be_false
+
+    # Test specific join syntaxes:
+    frank.untaggable_models.create!
+    TaggableModel.tagged_with('rails').scoped(:joins => :untaggable_models).all_tags.should have(2).items
+    TaggableModel.tagged_with('rails').scoped(:joins => { :untaggable_models => :taggable_model }).all_tags.should have(2).items
+    TaggableModel.tagged_with('rails').scoped(:joins => [:untaggable_models]).all_tags.should have(2).items
+  end
+
   it "should be able to set a custom tag context list" do
     bob = TaggableModel.create(:name => "Bob")
     bob.set_tag_list_on(:rotors, "spinning, jumping")
@@ -456,6 +498,17 @@ describe "Taggable" do
       TaggableModel.tag_counts_on(:tags, :order => 'tags.id').map(&:name).should == %w(bob kelso fork spoon)
     end
 
+    it "should have different tags_on for inherited models" do
+      @inherited_same.tag_list = "bob, kelso"
+      @inherited_same.save!
+      @inherited_different.tag_list = "fork, spoon"
+      @inherited_different.save!
+
+      InheritingTaggableModel.tags_on(:tags, :order => 'tags.id').map(&:name).should == %w(bob kelso)
+      AlteredInheritingTaggableModel.tags_on(:tags, :order => 'tags.id').map(&:name).should == %w(fork spoon)
+      TaggableModel.tags_on(:tags, :order => 'tags.id').map(&:name).should == %w(bob kelso fork spoon)
+    end
+
     it 'should store same tag without validation conflict' do
       @taggable.tag_list = 'one'
       @taggable.save!
@@ -492,6 +545,16 @@ describe "Taggable" do
       @taggable.tag_counts_on(:tags).length.should == 2
     end
 
+    it "should have tags_on" do
+      NonStandardIdTaggableModel.tags_on(:tags).all.should be_empty
+
+      @taggable.tag_list = ["awesome", "epic"]
+      @taggable.save
+
+      NonStandardIdTaggableModel.tags_on(:tags).length.should == 2
+      @taggable.tags_on(:tags).length.should == 2
+    end
+
     it "should be able to create tags" do
       @taggable.skill_list = "ruby, rails, css"
       @taggable.instance_variable_get("@skill_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
@@ -538,6 +601,12 @@ describe "Taggable" do
       @taggable.changes.should == {}
     end
   end
+
+  describe "Autogenerated methods" do
+    it "should be overridable" do
+      TaggableModel.create(:tag_list=>'woo').tag_list_submethod_called.should be_true
+    end
+  end
 end