acts-as-taggable-on 3.1.1 → 3.2.1

data/lib/acts_as_taggable_on/tagging.rb

@@ -1,5 +1,6 @@
 module ActsAsTaggableOn
   class Tagging < ::ActiveRecord::Base #:nodoc:
+    #TODO, remove from 4.0.0
     attr_accessible :tag,
                     :tag_id,
                     :context,
@@ -9,14 +10,15 @@ module ActsAsTaggableOn
                     :tagger,
                     :tagger_type,
                     :tagger_id if defined?(ActiveModel::MassAssignmentSecurity)
-    belongs_to :tag, :class_name => 'ActsAsTaggableOn::Tag' , :counter_cache => true
-    belongs_to :taggable, :polymorphic => true
-    belongs_to :tagger,   :polymorphic => true
+
+    belongs_to :tag, class_name: 'ActsAsTaggableOn::Tag' , counter_cache: true
+    belongs_to :taggable, polymorphic: true
+    belongs_to :tagger,   polymorphic: true
 
     validates_presence_of :context
     validates_presence_of :tag_id
 
-    validates_uniqueness_of :tag_id, :scope => [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
+    validates_uniqueness_of :tag_id, scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
 
     after_destroy :remove_unused_tags
 
@@ -24,10 +26,7 @@ module ActsAsTaggableOn
 
     def remove_unused_tags
       if ActsAsTaggableOn.remove_unused_tags
-        # TODO: use taggings_count in release 4.0.0
-        if tag.taggings.count.zero?
-          tag.destroy
-        end
+        tag.destroy if tag.taggings_count.zero?
       end
     end
   end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -1,6 +1,6 @@
 module ActsAsTaggableOn
   module TagsHelper
-    # See the README for an example using tag_cloud.
+    # See the wiki for an example using tag_cloud.
     def tag_cloud(tags, classes)
       return [] if tags.empty?
 

data/lib/acts_as_taggable_on/utils.rb

@@ -1,14 +1,26 @@
 module ActsAsTaggableOn
   module Utils
+    extend self
 
+    # Use ActsAsTaggableOn::Tag connection
     def connection
-      ::ActiveRecord::Base.connection
+      ActsAsTaggableOn::Tag.connection
     end
 
     def using_postgresql?
       connection && connection.adapter_name == 'PostgreSQL'
     end
 
+    def postgresql_version
+      if using_postgresql?
+        connection.execute("SHOW SERVER_VERSION").first["server_version"].to_f
+      end
+    end
+
+    def postgresql_support_json?
+      postgresql_version >= 9.2
+    end
+
     def using_sqlite?
       connection && connection.adapter_name == 'SQLite'
     end
@@ -19,14 +31,24 @@ module ActsAsTaggableOn
     end
 
     def using_case_insensitive_collation?
-      using_mysql? && ::ActiveRecord::Base.connection.collation =~ /_ci\Z/
+      using_mysql? && connection.collation =~ /_ci\Z/
+    end
+
+    def supports_concurrency?
+      !using_sqlite?
     end
 
     def sha_prefix(string)
       Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
     end
 
-    private
+    def active_record4?
+      ::ActiveRecord::VERSION::MAJOR == 4
+    end
+
+    def active_record42?
+      active_record4? && ::ActiveRecord::VERSION::MINOR >= 2
+    end
 
     def like_operator
       using_postgresql? ? 'ILIKE' : 'LIKE'

data/lib/acts_as_taggable_on/version.rb

@@ -1,4 +1,4 @@
 module ActsAsTaggableOn
-  VERSION = '3.1.1'
+  VERSION = '3.2.1'
 end
 

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -1,141 +1,136 @@
 # coding: utf-8
 require 'spec_helper'
 
-describe "Acts As Taggable On" do
-  before(:each) do
-    clean_database!
-  end
+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
+    expect(UntaggableModel).to_not be_taggable
   end
 
-  describe "Taggable Method Generation To Preserve Order" do
+  describe 'Taggable Method Generation To Preserve Order' do
     before(:each) do
-      clean_database!
       TaggableModel.tag_types = []
       TaggableModel.preserve_tag_order = false
       TaggableModel.acts_as_ordered_taggable_on(:ordered_tags)
-      @taggable = TaggableModel.new(:name => "Bob Jones")
+      @taggable = TaggableModel.new(name: 'Bob Jones')
     end
 
     it "should respond 'true' to preserve_tag_order?" do
-      @taggable.class.preserve_tag_order?.should be_true
+      expect(@taggable.class.preserve_tag_order?).to be_truthy
     end
   end
 
-  describe "Taggable Method Generation" do
+  describe 'Taggable Method Generation' do
     before(:each) do
-      clean_database!
       TaggableModel.tag_types = []
       TaggableModel.acts_as_taggable_on(:tags, :languages, :skills, :needs, :offerings)
-      @taggable = TaggableModel.new(:name => "Bob Jones")
+      @taggable = TaggableModel.new(name: 'Bob Jones')
     end
 
     it "should respond 'true' to taggable?" do
-      @taggable.class.should be_taggable
+      expect(@taggable.class).to be_taggable
     end
 
-    it "should create a class attribute for tag types" do
-      @taggable.class.should respond_to(:tag_types)
+    it 'should create a class attribute for tag types' do
+      expect(@taggable.class).to respond_to(:tag_types)
     end
 
-    it "should create an instance attribute for tag types" do
-      @taggable.should respond_to(:tag_types)
+    it 'should create an instance attribute for tag types' do
+      expect(@taggable).to respond_to(:tag_types)
     end
 
-    it "should have all tag types" do
-      @taggable.tag_types.should == [:tags, :languages, :skills, :needs, :offerings]
+    it 'should have all tag types' do
+      expect(@taggable.tag_types).to eq([: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?)
+    it 'should create a class attribute for preserve tag order' do
+      expect(@taggable.class).to respond_to(:preserve_tag_order?)
     end
 
-    it "should create an instance attribute for preserve tag order" do
-      @taggable.should respond_to(:preserve_tag_order?)
+    it 'should create an instance attribute for preserve tag order' do
+      expect(@taggable).to respond_to(:preserve_tag_order?)
     end
 
     it "should respond 'false' to preserve_tag_order?" do
-      @taggable.class.preserve_tag_order?.should be_false
+      expect(@taggable.class.preserve_tag_order?).to be_falsy
     end
 
-    it "should generate an association for each tag type" do
-      @taggable.should respond_to(:tags, :skills, :languages)
+    it 'should generate an association for each tag type' do
+      expect(@taggable).to respond_to(:tags, :skills, :languages)
     end
 
-    it "should add tagged_with and tag_counts to singleton" do
-      TaggableModel.should respond_to(:tagged_with, :tag_counts)
+    it 'should add tagged_with and tag_counts to singleton' do
+      expect(TaggableModel).to respond_to(:tagged_with, :tag_counts)
     end
 
-    it "should generate a tag_list accessor/setter for each tag type" do
-      @taggable.should respond_to(:tag_list, :skill_list, :language_list)
-      @taggable.should respond_to(:tag_list=, :skill_list=, :language_list=)
+    it 'should generate a tag_list accessor/setter for each tag type' do
+      expect(@taggable).to respond_to(:tag_list, :skill_list, :language_list)
+      expect(@taggable).to respond_to(:tag_list=, :skill_list=, :language_list=)
     end
 
-    it "should generate a tag_list accessor, that includes owned tags, for each tag type" do
-      @taggable.should respond_to(:all_tags_list, :all_skills_list, :all_languages_list)
+    it 'should generate a tag_list accessor, that includes owned tags, for each tag type' do
+      expect(@taggable).to respond_to(:all_tags_list, :all_skills_list, :all_languages_list)
     end
   end
 
-  describe "Reloading" do
-    it "should save a model instantiated by Model.find" do
-      taggable = TaggableModel.create!(:name => "Taggable")
+  describe 'Reloading' do
+    it 'should save a model instantiated by Model.find' do
+      taggable = TaggableModel.create!(name: 'Taggable')
       found_taggable = TaggableModel.find(taggable.id)
       found_taggable.save
     end
   end
 
-  describe "Matching Contexts" do
-    it "should find objects with tags of matching contexts" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = TaggableModel.create!(:name => "Taggable 2")
-      taggable3 = TaggableModel.create!(:name => "Taggable 3")
+  describe 'Matching Contexts' do
+    it 'should find objects with tags of matching contexts' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1')
+      taggable2 = TaggableModel.create!(name: 'Taggable 2')
+      taggable3 = TaggableModel.create!(name: 'Taggable 3')
 
-      taggable1.offering_list = "one, two"
+      taggable1.offering_list = 'one, two'
       taggable1.save!
 
-      taggable2.need_list = "one, two"
+      taggable2.need_list = 'one, two'
       taggable2.save!
 
-      taggable3.offering_list = "one, two"
+      taggable3.offering_list = 'one, two'
       taggable3.save!
 
-      taggable1.find_matching_contexts(:offerings, :needs).should include(taggable2)
-      taggable1.find_matching_contexts(:offerings, :needs).should_not include(taggable3)
+      expect(taggable1.find_matching_contexts(:offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts(:offerings, :needs)).to_not include(taggable3)
     end
 
-    it "should find other related objects with tags of matching contexts" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = OtherTaggableModel.create!(:name => "Taggable 2")
-      taggable3 = OtherTaggableModel.create!(:name => "Taggable 3")
+    it 'should find other related objects with tags of matching contexts' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1')
+      taggable2 = OtherTaggableModel.create!(name: 'Taggable 2')
+      taggable3 = OtherTaggableModel.create!(name: 'Taggable 3')
 
-      taggable1.offering_list = "one, two"
+      taggable1.offering_list = 'one, two'
       taggable1.save
 
-      taggable2.need_list = "one, two"
+      taggable2.need_list = 'one, two'
       taggable2.save
 
-      taggable3.offering_list = "one, two"
+      taggable3.offering_list = 'one, two'
       taggable3.save
 
-      taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should include(taggable2)
-      taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should_not include(taggable3)
+      expect(taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs)).to_not include(taggable3)
     end
 
-    it "should not include the object itself in the list of related objects with tags of matching contexts" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = TaggableModel.create!(:name => "Taggable 2")
+    it 'should not include the object itself in the list of related objects with tags of matching contexts' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1')
+      taggable2 = TaggableModel.create!(name: 'Taggable 2')
 
-      taggable1.offering_list = "one, two"
-      taggable1.need_list = "one, two"
+      taggable1.offering_list = 'one, two'
+      taggable1.need_list = 'one, two'
       taggable1.save
 
-      taggable2.need_list = "one, two"
+      taggable2.need_list = 'one, two'
       taggable2.save
 
-      taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should include(taggable2)
-      taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(taggable1)
+      expect(taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(taggable1)
     end
 
   end
@@ -143,121 +138,121 @@ describe "Acts As Taggable On" do
   describe 'Tagging Contexts' do
     it 'should eliminate duplicate tagging contexts ' do
       TaggableModel.acts_as_taggable_on(:skills, :skills)
-      TaggableModel.tag_types.freq[:skills].should_not == 3
+      expect(TaggableModel.tag_types.freq[:skills]).to_not eq(3)
     end
 
-    it "should not contain embedded/nested arrays" do
+    it 'should not contain embedded/nested arrays' do
       TaggableModel.acts_as_taggable_on([:array], [:array])
-      TaggableModel.tag_types.freq[[:array]].should == 0
+      expect(TaggableModel.tag_types.freq[[:array]]).to eq(0)
     end
 
-    it "should _flatten_ the content of arrays" do
+    it 'should _flatten_ the content of arrays' do
       TaggableModel.acts_as_taggable_on([:array], [:array])
-      TaggableModel.tag_types.freq[:array].should == 1
+      expect(TaggableModel.tag_types.freq[:array]).to eq(1)
     end
 
-    it "should not raise an error when passed nil" do
-      lambda {
-        TaggableModel.acts_as_taggable_on()
-      }.should_not raise_error
+    it 'should not raise an error when passed nil' do
+      expect(-> {
+        TaggableModel.acts_as_taggable_on
+      }).to_not raise_error
     end
 
-    it "should not raise an error when passed [nil]" do
-      lambda {
+    it 'should not raise an error when passed [nil]' do
+      expect(-> {
         TaggableModel.acts_as_taggable_on([nil])
-      }.should_not raise_error
+      }).to_not raise_error
     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") }
-     subject { @taggable }
-
-     it { should respond_to(:save_cached_tag_list) }
-     its(:cached_language_list) { should be_blank }
-     its(:cached_status_list)   { should be_blank }
-     its(:cached_glass_list)    { should be_blank }
-
-     context 'language taggings cache after update' do
-       before  { @taggable.update_attributes(:language_list => 'ruby, .net') }
-       subject { @taggable }
-
-       its(:language_list)        { should == ['ruby', '.net']}
-       its(:cached_language_list) { should == 'ruby, .net' }           # passes
-       its(:instance_variables)   { should     include((RUBY_VERSION < '1.9' ? '@language_list' : :@language_list)) }
-     end
-
-     context 'status taggings cache after update' do
-       before  { @taggable.update_attributes(:status_list => 'happy, married') }
-       subject { @taggable }
-
-       its(:status_list)        { should     == ['happy', 'married'] }
-       its(:cached_status_list) { should     == 'happy, married'     } # fails
-       its(:cached_status_list) { should_not == ''                   } # fails, is blank
-       its(:instance_variables) { should     include((RUBY_VERSION < '1.9' ? '@status_list' : :@status_list)) }
-       its(:instance_variables) { should_not include((RUBY_VERSION < '1.9' ? '@statu_list' : :@statu_list))  } # fails, note: one "s"
-
-     end
-
-     context 'glass taggings cache after update' do
-       before do
-         @taggable.update_attributes(:glass_list => 'rectangle, aviator')
-       end
-
-       subject { @taggable }
-       its(:glass_list)         { should     == ['rectangle', 'aviator'] }
-       its(:cached_glass_list)  { should     == 'rectangle, aviator'     } # fails
-       its(:cached_glass_list)  { should_not == ''                       } # fails, is blank
-       if RUBY_VERSION < '1.9'
-         its(:instance_variables) { should     include('@glass_list')      }
-         its(:instance_variables) { should_not include('@glas_list')       } # fails, note: one "s"
-       else
-         its(:instance_variables) { should     include(:@glass_list)      }
-         its(:instance_variables) { should_not include(:@glas_list)       } # fails, note: one "s"
-       end
-
-     end
-   end
+    describe 'caching' do
+      before  { @taggable = OtherCachedModel.new(name: 'John Smith') }
+      subject { @taggable }
+
+      it { should respond_to(:save_cached_tag_list) }
+      its(:cached_language_list) { should be_blank }
+      its(:cached_status_list)   { should be_blank }
+      its(:cached_glass_list)    { should be_blank }
+
+      context 'language taggings cache after update' do
+        before  { @taggable.update_attributes(language_list: 'ruby, .net') }
+        subject { @taggable }
+
+        its(:language_list)        { should == ['ruby', '.net']}
+        its(:cached_language_list) { should == 'ruby, .net' }           # passes
+        its(:instance_variables)   { should     include((RUBY_VERSION < '1.9' ? '@language_list' : :@language_list)) }
+      end
+
+      context 'status taggings cache after update' do
+        before  { @taggable.update_attributes(status_list: 'happy, married') }
+        subject { @taggable }
+
+        its(:status_list)        { should     == ['happy', 'married'] }
+        its(:cached_status_list) { should     == 'happy, married'     } # fails
+        its(:cached_status_list) { should_not == ''                   } # fails, is blank
+        its(:instance_variables) { should     include((RUBY_VERSION < '1.9' ? '@status_list' : :@status_list)) }
+        its(:instance_variables) { should_not include((RUBY_VERSION < '1.9' ? '@statu_list' : :@statu_list))  } # fails, note: one "s"
+
+      end
+
+      context 'glass taggings cache after update' do
+        before do
+          @taggable.update_attributes(glass_list: 'rectangle, aviator')
+        end
+
+        subject { @taggable }
+        its(:glass_list)         { should     == ['rectangle', 'aviator'] }
+        its(:cached_glass_list)  { should     == 'rectangle, aviator'     } # fails
+        its(:cached_glass_list)  { should_not == ''                       } # fails, is blank
+        if RUBY_VERSION < '1.9'
+          its(:instance_variables) { should     include('@glass_list')      }
+          its(:instance_variables) { should_not include('@glas_list')       } # fails, note: one "s"
+        else
+          its(:instance_variables) { should     include(:@glass_list)      }
+          its(:instance_variables) { should_not include(:@glas_list)       } # fails, note: one "s"
+        end
+
+      end
+    end
   end
 
-  describe "taggings" do
+  describe 'taggings' do
     before(:each) do
-      @taggable = TaggableModel.new(:name => "Art Kram")
+      @taggable = TaggableModel.new(name: 'Art Kram')
     end
 
-    it 'should return [] taggings' do
-      @taggable.taggings.should == []
+    it 'should return no taggings' do
+      expect(@taggable.taggings).to be_empty
     end
   end
 
-  describe "@@remove_unused_tags" do
+  describe '@@remove_unused_tags' do
     before do
-      @taggable = TaggableModel.create(:name => "Bob Jones")
-      @tag = ActsAsTaggableOn::Tag.create(:name => "awesome")
+      @taggable = TaggableModel.create(name: 'Bob Jones')
+      @tag = ActsAsTaggableOn::Tag.create(name: 'awesome')
 
-      @tagging = ActsAsTaggableOn::Tagging.create(:taggable => @taggable, :tag => @tag, :context => 'tags')
+      @tagging = ActsAsTaggableOn::Tagging.create(taggable: @taggable, tag: @tag, context: 'tags')
     end
 
-    context "if set to true" do
+    context 'if set to true' do
       before do
         ActsAsTaggableOn.remove_unused_tags = true
       end
 
-      it "should remove unused tags after removing taggings" do
+      it 'should remove unused tags after removing taggings' do
         @tagging.destroy
-        ActsAsTaggableOn::Tag.find_by_name("awesome").should be_nil
+        expect(ActsAsTaggableOn::Tag.find_by_name('awesome')).to be_nil
       end
     end
 
-    context "if set to false" do
+    context 'if set to false' do
       before do
         ActsAsTaggableOn.remove_unused_tags = false
       end
 
-      it "should not remove unused tags after removing taggings" do
+      it 'should not remove unused tags after removing taggings' do
         @tagging.destroy
-        ActsAsTaggableOn::Tag.find_by_name("awesome").should == @tag
+        expect(ActsAsTaggableOn::Tag.find_by_name('awesome')).to eq(@tag)
       end
     end
   end