acts-as-taggable-on 3.1.1 → 3.2.1

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -1,112 +1,109 @@
 require 'spec_helper'
 
-describe "acts_as_tagger" do
-  before(:each) do
-    clean_database!
-  end
+describe 'acts_as_tagger' do
 
-  describe "Tagger Method Generation" do
+  describe 'Tagger Method Generation' do
     before(:each) do
       @tagger = User.new
     end
 
-    it "should add #is_tagger? query method to the class-side" do
-      User.should respond_to(:is_tagger?)
+    it 'should add #is_tagger? query method to the class-side' do
+      expect(User).to respond_to(:is_tagger?)
     end
 
-    it "should return true from the class-side #is_tagger?" do
-      User.is_tagger?.should be_true
+    it 'should return true from the class-side #is_tagger?' do
+      expect(User.is_tagger?).to be_truthy
     end
 
-    it "should return false from the base #is_tagger?" do
-      ActiveRecord::Base.is_tagger?.should be_false
+    it 'should return false from the base #is_tagger?' do
+      expect(ActiveRecord::Base.is_tagger?).to be_falsy
     end
 
-    it "should add #is_tagger? query method to the singleton" do
-      @tagger.should respond_to(:is_tagger?)
+    it 'should add #is_tagger? query method to the singleton' do
+      expect(@tagger).to respond_to(:is_tagger?)
     end
 
-    it "should add #tag method on the instance-side" do
-      @tagger.should respond_to(:tag)
+    it 'should add #tag method on the instance-side' do
+      expect(@tagger).to respond_to(:tag)
     end
 
-    it "should generate an association for #owned_taggings and #owned_tags" do
-      @tagger.should respond_to(:owned_taggings, :owned_tags)
+    it 'should generate an association for #owned_taggings and #owned_tags' do
+      expect(@tagger).to respond_to(:owned_taggings, :owned_tags)
     end
   end
 
-  describe "#tag" do
+  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")
+        @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
+      it 'should by default not throw an exception ' do
+        expect(@taggable.tag_list_on(:foo)).to be_empty
+        expect(-> {
+          @tagger.tag(@taggable, with: 'this, and, that', on: :foo)
+        }).to_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')
+        expect(@taggable.tag_list_on(:here_ond_now)).to be_empty
+        @tagger.tag(@taggable, with: 'that', on: :here_ond_now)
+        expect(@taggable.tag_list_on(:here_ond_now)).to_not include('that')
+        expect(@taggable.all_tags_list_on(:here_ond_now)).to include('that')
       end
 
-      it "should show all the tag list when both public and owned tags exist" do
+      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
+        @tagger.tag(@taggable, with: 'java, lisp', on: :tags)
+        expect(@taggable.all_tags_on(:tags).map(&:name).sort).to eq(%w(ruby python java lisp).sort)
       end
 
-      it "should not add owned tags to the common list" do
+      it 'should not add owned tags to the common list' do
         @taggable.tag_list = 'ruby, python'
-        @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
-        @taggable.tag_list.should == %w(ruby python)
-        @tagger.tag(@taggable, :with => '', :on => :tags)
-        @taggable.tag_list.should == %w(ruby python)
+        @tagger.tag(@taggable, with: 'java, lisp', on: :tags)
+        expect(@taggable.tag_list).to eq(%w(ruby python))
+        @tagger.tag(@taggable, with: '', on: :tags)
+        expect(@taggable.tag_list).to eq(%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
+      it 'should throw an exception when the default is over-ridden' do
+        expect(@taggable.tag_list_on(:foo_boo)).to be_empty
+        expect(-> {
+          @tagger.tag(@taggable, with: 'this, and, that', on: :foo_boo, force: false)
+        }).to raise_error
       end
 
-      it "should not create the tag context on-the-fly when the default is over-ridden" do
-        @taggable.tag_list_on(:foo_boo).should be_empty
-        @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo_boo, :force=>false) rescue
-        @taggable.tag_list_on(:foo_boo).should be_empty
+      it 'should not create the tag context on-the-fly when the default is over-ridden' do
+        expect(@taggable.tag_list_on(:foo_boo)).to be_empty
+        @tagger.tag(@taggable, with: 'this, and, that', on: :foo_boo, force: false) rescue
+            expect(@taggable.tag_list_on(:foo_boo)).to 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 = 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_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)
+        @user_y.tag(@taggable, with: '', on: :tags)
+        @user_y.tag(@taggable, with: '', on: :tags)
       end
 
-      it "should delete owned tags" do
-        @user_y.owned_tags.should == []
+      it 'should delete owned tags' do
+        expect(@user_y.owned_tags).to be_empty
       end
 
-      it "should not delete other taggers tags" do
-        @user_x.owned_tags.should have(2).items
+      it 'should not delete other taggers tags' do
+        expect(@user_x.owned_tags.count).to eq(2)
       end
 
-      it "should not delete original tags" do
-        @taggable.all_tags_list_on(:tags).should include('plugin')
+      it 'should not delete original tags' do
+        expect(@taggable.all_tags_list_on(:tags)).to include('plugin')
       end
     end
   end

data/spec/acts_as_taggable_on/caching_spec.rb

@@ -1,77 +1,76 @@
 require 'spec_helper'
 
-describe "Acts As Taggable On" do
-
-  before(:each) do
-    clean_database!
-  end
+describe 'Acts As Taggable On' do
 
   describe 'Caching' do
     before(:each) do
-      @taggable = CachedModel.new(:name => "Bob Jones")
-      @another_taggable = OtherCachedModel.new(:name => "John Smith")
+      @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)
+    it 'should add saving of tag lists and cached tag lists to the instance' do
+      expect(@taggable).to respond_to(:save_cached_tag_list)
+      expect(@another_taggable).to respond_to(:save_cached_tag_list)
 
-      @taggable.should respond_to(:save_tags)
+      expect(@taggable).to 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)
+    it 'should add cached tag lists to the instance if cached column is not present' do
+      expect(TaggableModel.new(name: 'Art Kram')).to_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?)
+    it 'should generate a cached column checker for each tag type' do
+      expect(CachedModel).to respond_to(:caching_tag_list?)
+      expect(OtherCachedModel).to 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
+      expect(@taggable.cached_tag_list).to be_blank
+      expect(@another_taggable.cached_language_list).to be_blank
     end
 
     it 'should cache tags' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable.cached_tag_list.should == 'awesome, epic'
+      @taggable.update_attributes(tag_list: 'awesome, epic')
+      expect(@taggable.cached_tag_list).to eq('awesome, epic')
 
-      @another_taggable.update_attributes(:language_list => 'ruby, .net')
-      @another_taggable.cached_language_list.should == 'ruby, .net'
+      @another_taggable.update_attributes(language_list: 'ruby, .net')
+      expect(@another_taggable.cached_language_list).to eq('ruby, .net')
     end
 
     it 'should keep the cache' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable = CachedModel.find(@taggable)
+      @taggable.update_attributes(tag_list: 'awesome, epic')
+      @taggable = CachedModel.find(@taggable.id)
       @taggable.save!
-      @taggable.cached_tag_list.should == 'awesome, epic'
+      expect(@taggable.cached_tag_list).to eq('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'
+      @taggable.update_attributes(tag_list: 'awesome, epic')
+      @taggable.update_attributes(tag_list: 'awesome')
+      expect(@taggable.cached_tag_list).to eq('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
+      @taggable.update_attributes(tag_list: 'awesome, epic')
+      @taggable.update_attributes(tag_list: '')
+      expect(@taggable.cached_tag_list).to be_blank
     end
 
     it 'should have a tag list' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable.update_attributes(tag_list: 'awesome, epic')
       @taggable = CachedModel.find(@taggable.id)
-      @taggable.tag_list.sort.should == %w(awesome epic).sort
+      expect(@taggable.tag_list.sort).to eq(%w(awesome epic).sort)
     end
 
     it 'should keep the tag list' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable.update_attributes(tag_list: 'awesome, epic')
       @taggable = CachedModel.find(@taggable.id)
       @taggable.save!
-      @taggable.tag_list.sort.should == %w(awesome epic).sort
+      expect(@taggable.tag_list.sort).to eq(%w(awesome epic).sort)
     end
   end
 
+  describe 'CachingWithArray' do
+    pending '#TODO'
+  end
 end

data/spec/acts_as_taggable_on/related_spec.rb

@@ -1,143 +1,89 @@
 require 'spec_helper'
 
-describe "Acts As Taggable On" do
-  before(:each) do
-    clean_database!
-  end
-
-  describe "Related Objects" do
-    it "should find related objects based on tag names on context" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = TaggableModel.create!(:name => "Taggable 2")
-      taggable3 = TaggableModel.create!(:name => "Taggable 3")
+describe 'Acts As Taggable On' do
 
-      taggable1.tag_list = "one, two"
-      taggable1.save
+  describe 'Related Objects' do
 
-      taggable2.tag_list = "three, four"
-      taggable2.save
+    #TODO, shared example
+    it 'should find related objects based on tag names on context' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1',tag_list: 'one, two')
+      taggable2 = TaggableModel.create!(name: 'Taggable 2',tag_list: 'three, four')
+      taggable3 = TaggableModel.create!(name: 'Taggable 3',tag_list: 'one, four')
 
-      taggable3.tag_list = "one, four"
-      taggable3.save
-
-      taggable1.find_related_tags.should include(taggable3)
-      taggable1.find_related_tags.should_not include(taggable2)
+      expect(taggable1.find_related_tags).to include(taggable3)
+      expect(taggable1.find_related_tags).to_not include(taggable2)
     end
 
-    it "finds related tags for ordered taggable on" do
-      taggable1 = OrderedTaggableModel.create!(:name => "Taggable 1")
-      taggable2 = OrderedTaggableModel.create!(:name => "Taggable 2")
-      taggable3 = OrderedTaggableModel.create!(:name => "Taggable 3")
-
-      taggable1.colour_list = "one, two"
-      taggable1.save
+    it 'finds related tags for ordered taggable on' do
+      taggable1 = OrderedTaggableModel.create!(name: 'Taggable 1',colour_list: 'one, two')
+      taggable2 = OrderedTaggableModel.create!(name: 'Taggable 2',colour_list: 'three, four')
+      taggable3 = OrderedTaggableModel.create!(name: 'Taggable 3',colour_list: 'one, four')
 
-      taggable2.colour_list = "three, four"
-      taggable2.save
-
-      taggable3.colour_list = "one, four"
-      taggable3.save
-
-      taggable1.find_related_colours.should include(taggable3)
-      taggable1.find_related_colours.should_not include(taggable2)
+      expect(taggable1.find_related_colours).to include(taggable3)
+      expect(taggable1.find_related_colours).to_not include(taggable2)
     end
 
-    it "should find related objects based on tag names on context - non standard id" do
-      taggable1 = NonStandardIdTaggableModel.create!(:name => "Taggable 1")
-      taggable2 = NonStandardIdTaggableModel.create!(:name => "Taggable 2")
-      taggable3 = NonStandardIdTaggableModel.create!(:name => "Taggable 3")
-
-      taggable1.tag_list = "one, two"
-      taggable1.save
+    it 'should find related objects based on tag names on context - non standard id' do
+      taggable1 = NonStandardIdTaggableModel.create!(name: 'Taggable 1',tag_list: 'one, two')
+      taggable2 = NonStandardIdTaggableModel.create!(name: 'Taggable 2',tag_list: 'three, four')
+      taggable3 = NonStandardIdTaggableModel.create!(name: 'Taggable 3',tag_list: 'one, four')
 
-      taggable2.tag_list = "three, four"
-      taggable2.save
-
-      taggable3.tag_list = "one, four"
-      taggable3.save
-
-      taggable1.find_related_tags.should include(taggable3)
-      taggable1.find_related_tags.should_not include(taggable2)
+      expect(taggable1.find_related_tags).to include(taggable3)
+      expect(taggable1.find_related_tags).to_not include(taggable2)
     end
 
-    it "should find other related objects based on tag names on context" 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 based on tag names on context' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1',tag_list: 'one, two')
+      taggable2 = OtherTaggableModel.create!(name: 'Taggable 2',tag_list: 'three, four')
+      taggable3 = OtherTaggableModel.create!(name: 'Taggable 3',tag_list: 'one, four')
 
-      taggable1.tag_list = "one, two"
-      taggable1.save
+      expect(taggable1.find_related_tags_for(OtherTaggableModel)).to include(taggable3)
+      expect(taggable1.find_related_tags_for(OtherTaggableModel)).to_not include(taggable2)
+    end
 
-      taggable2.tag_list = "three, four"
-      taggable2.save
 
-      taggable3.tag_list = "one, four"
-      taggable3.save
+    shared_examples "a collection" do
+      it do
+        taggable1 = described_class.create!(name: 'Taggable 1', tag_list: 'one')
+        taggable2 = described_class.create!(name: 'Taggable 2', tag_list: 'one, two')
 
-      taggable1.find_related_tags_for(OtherTaggableModel).should include(taggable3)
-      taggable1.find_related_tags_for(OtherTaggableModel).should_not include(taggable2)
+        expect(taggable1.find_related_tags).to include(taggable2)
+        expect(taggable1.find_related_tags).to_not include(taggable1)
+      end
     end
 
-    it "should not include the object itself in the list of related objects" 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' do
+    describe TaggableModel do
+      it_behaves_like "a collection"
+    end
 
-      taggable1.tag_list = "one"
-      taggable1.save
+    # it 'should not include the object itself in the list of related objects - non standard id' do
+    describe NonStandardIdTaggableModel do
+      it_behaves_like "a collection"
+    end
 
-      taggable2.tag_list = "one, two"
-      taggable2.save
+    context 'Ignored Tags' do
+      let(:taggable1) { TaggableModel.create!(name: 'Taggable 1', tag_list: 'one, two, four') }
+      let(:taggable2) { TaggableModel.create!(name: 'Taggable 2', tag_list: 'two, three') }
+      let(:taggable3) { TaggableModel.create!(name: 'Taggable 3', tag_list: 'one, three') }
 
-      taggable1.find_related_tags.should include(taggable2)
-      taggable1.find_related_tags.should_not include(taggable1)
-    end
+      it 'should not include ignored tags in related search' do
+        expect(taggable1.find_related_tags(ignore: 'two')).to_not include(taggable2)
+        expect(taggable1.find_related_tags(ignore: 'two')).to include(taggable3)
+      end
 
-    it "should not include the object itself in the list of related objects - non standard id" do
-      taggable1 = NonStandardIdTaggableModel.create!(:name => "Taggable 1")
-      taggable2 = NonStandardIdTaggableModel.create!(:name => "Taggable 2")
+      it 'should accept array of ignored tags' do
+        taggable4 = TaggableModel.create!(name: 'Taggable 4', tag_list: 'four')
 
-      taggable1.tag_list = "one"
-      taggable1.save
 
-      taggable2.tag_list = "one, two"
-      taggable2.save
+        expect(taggable1.find_related_tags(ignore: ['two', 'four'])).to_not include(taggable2)
+        expect(taggable1.find_related_tags(ignore: ['two', 'four'])).to_not include(taggable4)
+      end
 
-      taggable1.find_related_tags.should include(taggable2)
-      taggable1.find_related_tags.should_not include(taggable1)
+      it 'should accept symbols as ignored tags' do
+        expect(taggable1.find_related_tags(ignore: :two)).to_not include(taggable2)
+      end
     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
-
   end
 end