acts-as-taggable-on 3.1.1 → 3.2.2

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

data/spec/acts_as_taggable_on/single_table_inheritance_spec.rb

@@ -1,149 +1,145 @@
 require 'spec_helper'
 
-describe "Single Table Inheritance" do
+describe 'Single Table Inheritance' do
+  let(:taggable) { TaggableModel.new(name: 'taggable model') }
 
-  before(:each) do
-    clean_database!
-  end
-
-  let(:taggable)            { TaggableModel.new(:name => "taggable model") }
-
-  let(:inheriting_model)    { InheritingTaggableModel.new(:name => "Inheriting Taggable Model") }
-  let(:altered_inheriting)  { AlteredInheritingTaggableModel.new(:name => "Altered Inheriting Model") }
+  let(:inheriting_model) { InheritingTaggableModel.new(name: 'Inheriting Taggable Model') }
+  let(:altered_inheriting) { AlteredInheritingTaggableModel.new(name: 'Altered Inheriting Model') }
 
   1.upto(4) do |n|
-    let(:"inheriting_#{n}") { InheritingTaggableModel.new(:name => "Inheriting Model #{n}") }
+    let(:"inheriting_#{n}") { InheritingTaggableModel.new(name: "Inheriting Model #{n}") }
   end
 
-  let(:student)             { Student.create! }
+  let(:student) { Student.create! }
 
-  describe "tag contexts" do
-    it "should pass on to STI-inherited models" do
-      inheriting_model.should respond_to(:tag_list, :skill_list, :language_list)
-      altered_inheriting.should respond_to(:tag_list, :skill_list, :language_list)
+  describe 'tag contexts' do
+    it 'should pass on to STI-inherited models' do
+      expect(inheriting_model).to respond_to(:tag_list, :skill_list, :language_list)
+      expect(altered_inheriting).to respond_to(:tag_list, :skill_list, :language_list)
     end
 
-    it "should pass on to altered STI models" do
-      altered_inheriting.should respond_to(:part_list)
+    it 'should pass on to altered STI models' do
+      expect(altered_inheriting).to respond_to(:part_list)
     end
   end
 
-  context "matching contexts" do
+  context 'matching contexts' do
 
     before do
-      inheriting_1.offering_list = "one, two"
-      inheriting_1.need_list = "one, two"
+      inheriting_1.offering_list = 'one, two'
+      inheriting_1.need_list = 'one, two'
       inheriting_1.save!
 
-      inheriting_2.need_list = "one, two"
+      inheriting_2.need_list = 'one, two'
       inheriting_2.save!
 
-      inheriting_3.offering_list = "one, two"
+      inheriting_3.offering_list = 'one, two'
       inheriting_3.save!
 
-      inheriting_4.tag_list = "one, two, three, four"
+      inheriting_4.tag_list = 'one, two, three, four'
       inheriting_4.save!
 
-      taggable.need_list = "one, two"
+      taggable.need_list = 'one, two'
       taggable.save!
     end
 
-    it "should find objects with tags of matching contexts" do
-      inheriting_1.find_matching_contexts(:offerings, :needs).should      include(inheriting_2)
-      inheriting_1.find_matching_contexts(:offerings, :needs).should_not  include(inheriting_3)
-      inheriting_1.find_matching_contexts(:offerings, :needs).should_not  include(inheriting_4)
-      inheriting_1.find_matching_contexts(:offerings, :needs).should_not  include(taggable)
+    it 'should find objects with tags of matching contexts' do
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to include(inheriting_2)
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_3)
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_4)
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(taggable)
 
-      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should     include(inheriting_2)
-      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(inheriting_3)
-      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(inheriting_4)
-      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should     include(taggable)
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(inheriting_2)
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_3)
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_4)
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(taggable)
     end
 
-    it "should not include the object itself in the list of related objects with tags of matching contexts" do
-      inheriting_1.find_matching_contexts(:offerings, :needs).should_not include(inheriting_1)
-      inheriting_1.find_matching_contexts_for(InheritingTaggableModel, :offerings, :needs).should_not include(inheriting_1)
-      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(inheriting_1)
+    it 'should not include the object itself in the list of related objects with tags of matching contexts' do
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_1)
+      expect(inheriting_1.find_matching_contexts_for(InheritingTaggableModel, :offerings, :needs)).to_not include(inheriting_1)
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_1)
     end
   end
 
-  context "find related tags" do
+  context 'find related tags' do
     before do
-      inheriting_1.tag_list = "one, two"
+      inheriting_1.tag_list = 'one, two'
       inheriting_1.save
 
-      inheriting_2.tag_list = "three, four"
+      inheriting_2.tag_list = 'three, four'
       inheriting_2.save
 
-      inheriting_3.tag_list = "one, four"
+      inheriting_3.tag_list = 'one, four'
       inheriting_3.save
 
-      taggable.tag_list = "one, two, three, four"
+      taggable.tag_list = 'one, two, three, four'
       taggable.save
     end
 
-    it "should find related objects based on tag names on context" do
-      inheriting_1.find_related_tags.should include(inheriting_3)
-      inheriting_1.find_related_tags.should_not include(inheriting_2)
-      inheriting_1.find_related_tags.should_not include(taggable)
+    it 'should find related objects based on tag names on context' do
+      expect(inheriting_1.find_related_tags).to include(inheriting_3)
+      expect(inheriting_1.find_related_tags).to_not include(inheriting_2)
+      expect(inheriting_1.find_related_tags).to_not include(taggable)
 
-      inheriting_1.find_related_tags_for(TaggableModel).should include(inheriting_3)
-      inheriting_1.find_related_tags_for(TaggableModel).should_not include(inheriting_2)
-      inheriting_1.find_related_tags_for(TaggableModel).should include(taggable)
+      expect(inheriting_1.find_related_tags_for(TaggableModel)).to include(inheriting_3)
+      expect(inheriting_1.find_related_tags_for(TaggableModel)).to_not include(inheriting_2)
+      expect(inheriting_1.find_related_tags_for(TaggableModel)).to include(taggable)
     end
 
-    it "should not include the object itself in the list of related objects" do
-      inheriting_1.find_related_tags.should_not include(inheriting_1)
-      inheriting_1.find_related_tags_for(InheritingTaggableModel).should_not include(inheriting_1)
-      inheriting_1.find_related_tags_for(TaggableModel).should_not include(inheriting_1)
+    it 'should not include the object itself in the list of related objects' do
+      expect(inheriting_1.find_related_tags).to_not include(inheriting_1)
+      expect(inheriting_1.find_related_tags_for(InheritingTaggableModel)).to_not include(inheriting_1)
+      expect(inheriting_1.find_related_tags_for(TaggableModel)).to_not include(inheriting_1)
     end
   end
 
-  describe "tag list" do
+  describe 'tag list' do
     before do
-      @inherited_same = InheritingTaggableModel.new(:name => "inherited same")
-      @inherited_different = AlteredInheritingTaggableModel.new(:name => "inherited different")
+      @inherited_same = InheritingTaggableModel.new(name: 'inherited same')
+      @inherited_different = AlteredInheritingTaggableModel.new(name: 'inherited different')
     end
 
-    it "should be able to save tags for inherited models" do
-      inheriting_model.tag_list = "bob, kelso"
+    #TODO, shared example
+    it 'should be able to save tags for inherited models' do
+      inheriting_model.tag_list = 'bob, kelso'
       inheriting_model.save
-      InheritingTaggableModel.tagged_with("bob").first.should == inheriting_model
+      expect(InheritingTaggableModel.tagged_with('bob').first).to eq(inheriting_model)
     end
 
-    it "should find STI tagged models on the superclass" do
-      inheriting_model.tag_list = "bob, kelso"
+    it 'should find STI tagged models on the superclass' do
+      inheriting_model.tag_list = 'bob, kelso'
       inheriting_model.save
-      TaggableModel.tagged_with("bob").first.should == inheriting_model
+      expect(TaggableModel.tagged_with('bob').first).to eq(inheriting_model)
     end
 
-    it "should be able to add on contexts only to some subclasses" do
-      altered_inheriting.part_list = "fork, spoon"
+    it 'should be able to add on contexts only to some subclasses' do
+      altered_inheriting.part_list = 'fork, spoon'
       altered_inheriting.save
-      InheritingTaggableModel.tagged_with("fork", :on => :parts).should be_empty
-      AlteredInheritingTaggableModel.tagged_with("fork", :on => :parts).first.should == altered_inheriting
+      expect(InheritingTaggableModel.tagged_with('fork', on: :parts)).to be_empty
+      expect(AlteredInheritingTaggableModel.tagged_with('fork', on: :parts).first).to eq(altered_inheriting)
     end
 
-    it "should have different tag_counts_on for inherited models" do
-      inheriting_model.tag_list = "bob, kelso"
+    it 'should have different tag_counts_on for inherited models' do
+      inheriting_model.tag_list = 'bob, kelso'
       inheriting_model.save!
-      altered_inheriting.tag_list = "fork, spoon"
+      altered_inheriting.tag_list = 'fork, spoon'
       altered_inheriting.save!
 
-      InheritingTaggableModel.tag_counts_on(:tags, :order => 'tags.id').map(&:name).should == %w(bob kelso)
-      AlteredInheritingTaggableModel.tag_counts_on(:tags, :order => 'tags.id').map(&:name).should == %w(fork spoon)
-      TaggableModel.tag_counts_on(:tags, :order => 'tags.id').map(&:name).should == %w(bob kelso fork spoon)
+      expect(InheritingTaggableModel.tag_counts_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso))
+      expect(AlteredInheritingTaggableModel.tag_counts_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(fork spoon))
+      expect(TaggableModel.tag_counts_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso fork spoon))
     end
 
-    it "should have different tags_on for inherited models" do
-      inheriting_model.tag_list = "bob, kelso"
+    it 'should have different tags_on for inherited models' do
+      inheriting_model.tag_list = 'bob, kelso'
       inheriting_model.save!
-      altered_inheriting.tag_list = "fork, spoon"
+      altered_inheriting.tag_list = 'fork, spoon'
       altered_inheriting.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)
+      expect(InheritingTaggableModel.tags_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso))
+      expect(AlteredInheritingTaggableModel.tags_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(fork spoon))
+      expect(TaggableModel.tags_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso fork spoon))
     end
 
     it 'should store same tag without validation conflict' do
@@ -153,35 +149,62 @@ describe "Single Table Inheritance" do
       inheriting_model.tag_list = 'one'
       inheriting_model.save!
 
-      inheriting_model.update_attributes! :name => 'foo'
+      inheriting_model.update_attributes! name: 'foo'
     end
   end
 
-  describe "ownership" do
-    it "should have taggings" do
-      student.tag(taggable, :with=>'ruby,scheme', :on=>:tags)
-      student.owned_taggings.should have(2).tags
+  describe 'ownership' do
+    it 'should have taggings' do
+      student.tag(taggable, with: 'ruby,scheme', on: :tags)
+      expect(student.owned_taggings.count).to eq(2)
     end
 
-    it "should have tags" do
-      student.tag(taggable, :with=>'ruby,scheme', :on=>:tags)
-      student.owned_tags.should have(2).tags
+    it 'should have tags' do
+      student.tag(taggable, with: 'ruby,scheme', on: :tags)
+      expect(student.owned_tags.count).to eq(2)
     end
 
-    it "should return tags for the inheriting tagger" do
-      student.tag(taggable, :with => 'ruby, scheme', :on => :tags)
-      taggable.tags_from(student).should match_array(%w(ruby scheme))
+    it 'should return tags for the inheriting tagger' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      expect(taggable.tags_from(student)).to eq(%w(ruby scheme))
     end
 
-    it "returns owner tags on the tagger" do
-      student.tag(taggable, :with => 'ruby, scheme', :on => :tags)
-      taggable.owner_tags_on(student, :tags).should have(2).tags
+    it 'returns owner tags on the tagger' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      expect(taggable.owner_tags_on(student, :tags).count).to eq(2)
     end
 
-    it "should scope objects returned by tagged_with by owners" do
-      student.tag(taggable, :with => 'ruby, scheme', :on => :tags)
-      TaggableModel.tagged_with(%w(ruby scheme), :owned_by => student).should have(1).tag
+    it 'should scope objects returned by tagged_with by owners' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      expect(TaggableModel.tagged_with(%w(ruby scheme), owned_by: student).count).to eq(1)
     end
   end
 
+  describe 'a subclass of Tag' do
+    let(:company) { Company.new(:name => 'Dewey, Cheatham & Howe') }
+    let(:user) { User.create! }
+
+    subject { Market.create! :name => 'finance' }
+
+    its(:type) { should eql 'Market' }
+
+    it 'sets STI type through string list' do
+      company.market_list = 'law, accounting'
+      company.save!
+      expect(Market.count).to eq(2)
+    end
+
+    it 'does not interfere with a normal Tag context on the same model' do
+      company.location_list = 'cambridge'
+      company.save!
+      expect(ActsAsTaggableOn::Tag.where(name: 'cambridge', type: nil)).to_not be_empty
+    end
+
+    it 'is returned with proper type through ownership' do
+      user.tag(company, :with => 'ripoffs, rackets', :on => :markets)
+      tags = company.owner_tags_on(user, :markets)
+      expect(tags.all? { |tag| tag.is_a? Market }).to be_truthy
+    end
+  end
 end
+