acts-as-taggable-on 2.4.0 → 2.4.1

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../spec_helper', __FILE__)
+require 'spec_helper'
 
 describe "acts_as_tagger" do
   before(:each) do
@@ -7,15 +7,15 @@ describe "acts_as_tagger" do
   
   describe "Tagger Method Generation" do
     before(:each) do
-      @tagger = TaggableUser.new()
+      @tagger = User.new
     end
 
     it "should add #is_tagger? query method to the class-side" do
-      TaggableUser.should respond_to(:is_tagger?)
+      User.should respond_to(:is_tagger?)
     end
     
     it "should return true from the class-side #is_tagger?" do
-      TaggableUser.is_tagger?.should be_true
+      User.is_tagger?.should be_true
     end
     
     it "should return false from the base #is_tagger?" do
@@ -38,7 +38,7 @@ describe "acts_as_tagger" do
   describe "#tag" do
     context 'when called with a non-existent tag context' do
       before(:each) do
-        @tagger = TaggableUser.new()
+        @tagger = User.new
         @taggable = TaggableModel.new(:name=>"Richard Prior")
       end
       
@@ -86,8 +86,8 @@ describe "acts_as_tagger" do
     
     describe "when called by multiple tagger's" do
       before(:each) do
-        @user_x = TaggableUser.create(:name => "User X")
-        @user_y = TaggableUser.create(:name => "User Y")
+        @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)
@@ -111,4 +111,4 @@ describe "acts_as_tagger" do
     end
   end
 
-end
+end

data/spec/acts_as_taggable_on/related_spec.rb

@@ -0,0 +1,143 @@
+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")
+
+      taggable1.tag_list = "one, two"
+      taggable1.save
+
+      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)
+    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
+
+      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)
+    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
+
+      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)
+    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")
+
+      taggable1.tag_list = "one, two"
+      taggable1.save
+
+      taggable2.tag_list = "three, four"
+      taggable2.save
+
+      taggable3.tag_list = "one, four"
+      taggable3.save
+
+      taggable1.find_related_tags_for(OtherTaggableModel).should include(taggable3)
+      taggable1.find_related_tags_for(OtherTaggableModel).should_not include(taggable2)
+    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")
+
+      taggable1.tag_list = "one"
+      taggable1.save
+
+      taggable2.tag_list = "one, two"
+      taggable2.save
+
+      taggable1.find_related_tags.should include(taggable2)
+      taggable1.find_related_tags.should_not include(taggable1)
+    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")
+
+      taggable1.tag_list = "one"
+      taggable1.save
+
+      taggable2.tag_list = "one, two"
+      taggable2.save
+
+      taggable1.find_related_tags.should include(taggable2)
+      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
+
+  end
+end

data/spec/acts_as_taggable_on/single_table_inheritance_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe "Single Table Inheritance" do
+
+  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") }
+
+  1.upto(4) do |n|
+    let(:"inheriting_#{n}") { InheritingTaggableModel.new(:name => "Inheriting Model #{n}") }
+  end
+
+  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)
+    end
+
+    it "should pass on to altered STI models" do
+      altered_inheriting.should respond_to(:part_list)
+    end
+  end
+
+  context "matching contexts" do
+
+    before do
+      inheriting_1.offering_list = "one, two"
+      inheriting_1.need_list = "one, two"
+      inheriting_1.save!
+
+      inheriting_2.need_list = "one, two"
+      inheriting_2.save!
+
+      inheriting_3.offering_list = "one, two"
+      inheriting_3.save!
+
+      inheriting_4.tag_list = "one, two, three, four"
+      inheriting_4.save!
+
+      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)
+
+      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)
+    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)
+    end
+  end
+
+  context "find related tags" do
+    before do
+      inheriting_1.tag_list = "one, two"
+      inheriting_1.save
+
+      inheriting_2.tag_list = "three, four"
+      inheriting_2.save
+
+      inheriting_3.tag_list = "one, four"
+      inheriting_3.save
+
+      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)
+
+      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)
+    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)
+    end
+  end
+
+  describe "tag list" do
+    before do
+      @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"
+      inheriting_model.save
+      InheritingTaggableModel.tagged_with("bob").first.should == inheriting_model
+    end
+
+    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
+    end
+
+    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
+    end
+
+    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.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)
+    end
+
+    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.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!
+
+      inheriting_model.tag_list = 'one'
+      inheriting_model.save!
+
+      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
+    end
+
+    it "should have tags" do
+      student.tag(taggable, :with=>'ruby,scheme', :on=>:tags)
+      student.owned_tags.should have(2).tags
+    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))
+    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
+    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
+    end
+  end
+
+end

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -1,5 +1,5 @@
-# -*- coding: utf-8 -*-
-require File.expand_path('../../spec_helper', __FILE__)
+# encoding: utf-8
+require 'spec_helper'
 
 describe ActsAsTaggableOn::TagList do
   let(:tag_list) { ActsAsTaggableOn::TagList.new("awesome","radical") }

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -1,6 +1,5 @@
-#encoding: utf-8
-
-require File.expand_path('../../spec_helper', __FILE__)
+# encoding: utf-8
+require 'spec_helper'
 
 describe ActsAsTaggableOn::Tag do
   before(:each) do
@@ -209,4 +208,4 @@ describe ActsAsTaggableOn::Tag do
       end
     end
   end
-end
+end

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -1,11 +1,11 @@
-require File.expand_path('../../spec_helper', __FILE__)
+require 'spec_helper'
 
 describe "Taggable To Preserve Order" do
   before(:each) do
     clean_database!
     @taggable = OrderedTaggableModel.new(:name => "Bob Jones")
   end
-  
+
   it "should have tag types" do
     [:tags, :colours].each do |type|
       OrderedTaggableModel.tag_types.should include type
@@ -13,21 +13,21 @@ describe "Taggable To Preserve Order" do
 
     @taggable.tag_types.should == OrderedTaggableModel.tag_types
   end
-  
+
   it "should have tag associations" do
     [:tags, :colours].each do |type|
       @taggable.respond_to?(type).should be_true
       @taggable.respond_to?("#{type.to_s.singularize}_taggings").should be_true
     end
   end
-  
-  it "should have tag associations ordered by id" do
-    [:tags, :colours].each do |type|
-      OrderedTaggableModel.reflect_on_association(type).options[:order].should include('id')
-      OrderedTaggableModel.reflect_on_association("#{type.to_s.singularize}_taggings".to_sym).options[:order].should include('id')
-    end
-  end
-  
+
+  # it "should have tag associations ordered by id" do
+  #   [:tags, :colours].each do |type|
+  #     OrderedTaggableModel.reflect_on_association(type).options[:order].should include('id')
+  #     OrderedTaggableModel.reflect_on_association("#{type.to_s.singularize}_taggings".to_sym).options[:order].should include('id')
+  #   end
+  # end
+
   it "should have tag methods" do
     [:tags, :colours].each do |type|
       @taggable.respond_to?("#{type.to_s.singularize}_list").should be_true
@@ -40,69 +40,69 @@ describe "Taggable To Preserve Order" do
     # create
     @taggable.tag_list = "rails, ruby, css"
     @taggable.instance_variable_get("@tag_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
-    
+
     lambda {
       @taggable.save
     }.should change(ActsAsTaggableOn::Tag, :count).by(3)
-    
+
     @taggable.reload
     @taggable.tag_list.should == %w(rails ruby css)
-    
+
     # update
     @taggable.tag_list = "pow, ruby, rails"
     @taggable.save
-        
+
     @taggable.reload
     @taggable.tag_list.should == %w(pow ruby rails)
-    
+
     # update with no change
     @taggable.tag_list = "pow, ruby, rails"
     @taggable.save
-        
+
     @taggable.reload
     @taggable.tag_list.should == %w(pow ruby rails)
-    
+
     # update to clear tags
     @taggable.tag_list = ""
     @taggable.save
-        
+
     @taggable.reload
     @taggable.tag_list.should == []
   end
-  
+
   it "should return tag objects in the order the tags were created" do
     # create
     @taggable.tag_list = "pow, ruby, rails"
     @taggable.instance_variable_get("@tag_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
-    
+
     lambda {
       @taggable.save
     }.should change(ActsAsTaggableOn::Tag, :count).by(3)
-    
+
     @taggable.reload
     @taggable.tags.map{|t| t.name}.should == %w(pow ruby rails)
-    
+
     # update
     @taggable.tag_list = "rails, ruby, css, pow"
     @taggable.save
-    
+
     @taggable.reload
     @taggable.tags.map{|t| t.name}.should == %w(rails ruby css pow)
   end
-  
+
   it "should return tag objects in tagging id order" do
     # create
     @taggable.tag_list = "pow, ruby, rails"
     @taggable.save
-    
+
     @taggable.reload
     ids = @taggable.tags.map{|t| t.taggings.first.id}
     ids.should == ids.sort
-    
+
     # update
     @taggable.tag_list = "rails, ruby, css, pow"
     @taggable.save
-    
+
     @taggable.reload
     ids = @taggable.tags.map{|t| t.taggings.first.id}
     ids.should == ids.sort
@@ -125,7 +125,7 @@ describe "Taggable" do
   end
 
   it "should have tag_counts_on" do
-    TaggableModel.tag_counts_on(:tags).all.should be_empty
+    TaggableModel.tag_counts_on(:tags).should be_empty
 
     @taggable.tag_list = ["awesome", "epic"]
     @taggable.save
@@ -135,7 +135,7 @@ describe "Taggable" do
   end
 
   it "should have tags_on" do
-    TaggableModel.tags_on(:tags).all.should be_empty
+    TaggableModel.tags_on(:tags).should be_empty
 
     @taggable.tag_list = ["awesome", "epic"]
     @taggable.save
@@ -231,7 +231,7 @@ describe "Taggable" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "Ruby")
 
-    ActsAsTaggableOn::Tag.find(:all).size.should == 1
+    ActsAsTaggableOn::Tag.all.size.should == 1
     TaggableModel.tagged_with("ruby").to_a.should == TaggableModel.tagged_with("Ruby").to_a
   end
 
@@ -239,8 +239,8 @@ describe "Taggable" 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.tag_counts.all.should_not be_empty
-    TaggableModel.skill_counts.all.should_not be_empty
+    TaggableModel.tag_counts.should_not be_empty
+    TaggableModel.skill_counts.should_not be_empty
   end
 
   it "should be able to get all tag counts on model as whole" do
@@ -248,7 +248,7 @@ describe "Taggable" do
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
     charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
 
-    TaggableModel.all_tag_counts.all.should_not be_empty
+    TaggableModel.all_tag_counts.should_not be_empty
     TaggableModel.all_tag_counts(:order => 'tags.id').first.count.should == 3 # ruby
   end
 
@@ -257,7 +257,7 @@ describe "Taggable" do
     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.should_not be_empty
     TaggableModel.all_tags(:order => 'tags.id').first.name.should == "ruby"
   end
 
@@ -310,9 +310,9 @@ describe "Taggable" do
 
     # Test specific join syntaxes:
     frank.untaggable_models.create!
-    TaggableModel.tagged_with('rails').scoped(:joins => :untaggable_models).all_tag_counts.should have(2).items
-    TaggableModel.tagged_with('rails').scoped(:joins => { :untaggable_models => :taggable_model }).all_tag_counts.should have(2).items
-    TaggableModel.tagged_with('rails').scoped(:joins => [:untaggable_models]).all_tag_counts.should have(2).items
+    TaggableModel.tagged_with('rails').joins(:untaggable_models).all_tag_counts.should have(2).items
+    TaggableModel.tagged_with('rails').joins(:untaggable_models => :taggable_model).all_tag_counts.should have(2).items
+    TaggableModel.tagged_with('rails').joins([:untaggable_models]).all_tag_counts.should have(2).items
   end
 
   it 'should only return tags for the available scope' do
@@ -325,9 +325,9 @@ describe "Taggable" do
 
     # 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
+    TaggableModel.tagged_with('rails').joins(:untaggable_models).all_tags.should have(2).items
+    TaggableModel.tagged_with('rails').joins({ :untaggable_models => :taggable_model }).all_tags.should have(2).items
+    TaggableModel.tagged_with('rails').joins([:untaggable_models]).all_tags.should have(2).items
   end
 
   it "should be able to set a custom tag context list" do
@@ -461,65 +461,6 @@ describe "Taggable" do
     end
   end
 
-  describe "Single Table Inheritance" do
-    before do
-      @taggable = TaggableModel.new(:name => "taggable")
-      @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
-      @inherited_same.tag_list = "bob, kelso"
-      @inherited_same.save
-      InheritingTaggableModel.tagged_with("bob").first.should == @inherited_same
-    end
-
-    it "should find STI tagged models on the superclass" do
-      @inherited_same.tag_list = "bob, kelso"
-      @inherited_same.save
-      TaggableModel.tagged_with("bob").first.should == @inherited_same
-    end
-
-    it "should be able to add on contexts only to some subclasses" do
-      @inherited_different.part_list = "fork, spoon"
-      @inherited_different.save
-      InheritingTaggableModel.tagged_with("fork", :on => :parts).should be_empty
-      AlteredInheritingTaggableModel.tagged_with("fork", :on => :parts).first.should == @inherited_different
-    end
-
-    it "should have different tag_counts_on for inherited models" do
-      @inherited_same.tag_list = "bob, kelso"
-      @inherited_same.save!
-      @inherited_different.tag_list = "fork, spoon"
-      @inherited_different.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)
-    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!
-
-      @inherited_same.tag_list = 'one'
-      @inherited_same.save!
-
-      @inherited_same.update_attributes! :name => 'foo'
-    end
-  end
-
   describe "NonStandardIdTaggable" do
     before(:each) do
       clean_database!
@@ -536,7 +477,7 @@ describe "Taggable" do
     end
 
     it "should have tag_counts_on" do
-      NonStandardIdTaggableModel.tag_counts_on(:tags).all.should be_empty
+      NonStandardIdTaggableModel.tag_counts_on(:tags).should be_empty
 
       @taggable.tag_list = ["awesome", "epic"]
       @taggable.save
@@ -546,7 +487,7 @@ describe "Taggable" do
     end
 
     it "should have tags_on" do
-      NonStandardIdTaggableModel.tags_on(:tags).all.should be_empty
+      NonStandardIdTaggableModel.tags_on(:tags).should be_empty
 
       @taggable.tag_list = ["awesome", "epic"]
       @taggable.save
@@ -581,24 +522,94 @@ describe "Taggable" do
   end
 
   describe "Dirty Objects" do
-    before(:each) do
-      @taggable = TaggableModel.create(:tag_list => "awesome, epic")
-    end
+    context "with un-contexted tags" do
+      before(:each) do
+        @taggable = TaggableModel.create(:tag_list => "awesome, epic")
+      end
 
-    it 'should show changes of dirty object' do
-      @taggable.changes.should == {}
-      @taggable.tag_list = 'one'
-      @taggable.changes.should == {"tag_list"=>["awesome, epic", ["one"]]}
+      context "when tag_list changed" do
+        before(:each) do
+          @taggable.changes.should == {}
+          @taggable.tag_list = 'one'
+        end
 
-      @taggable.tag_list_changed?.should be_true
-      @taggable.tag_list_was.should == "awesome, epic"
-      @taggable.tag_list_change.should == ["awesome, epic", ["one"]]
+        it 'should show changes of dirty object' do
+          @taggable.changes.should == {"tag_list"=>["awesome, epic", ["one"]]}
+        end
+
+        it 'flags tag_list as changed' do
+          @taggable.tag_list_changed?.should be_true
+        end
+
+        it 'preserves original value' do
+          @taggable.tag_list_was.should == "awesome, epic"
+        end
+
+        it 'shows what the change was' do
+          @taggable.tag_list_change.should == ["awesome, epic", ["one"]]
+        end
+      end
+
+      context 'when tag_list is the same' do
+        before(:each) do
+          @taggable.tag_list = "awesome, epic"
+        end
+
+        it 'is not flagged as changed' do
+          @taggable.tag_list_changed?.should be_false
+        end
+
+        it 'does not show any changes to the taggable item' do
+          @taggable.changes.should == {}
+        end
+      end
     end
 
-    it 'should show no changes if the same tag_list' do
-      @taggable.tag_list = "awesome, epic"
-      @taggable.tag_list_changed?.should be_false
-      @taggable.changes.should == {}
+    context "with context tags" do
+      before(:each) do
+        @taggable = TaggableModel.create(:language_list => "awesome, epic")
+      end
+
+      context "when language_list changed" do
+        before(:each) do
+          @taggable.changes.should == {}
+          @taggable.language_list = 'one'
+        end
+
+        it 'should show changes of dirty object' do
+          @taggable.changes.should == {"language_list"=>["awesome, epic", ["one"]]}
+        end
+
+        it 'flags language_list as changed' do
+          @taggable.language_list_changed?.should be_true
+        end
+
+        it 'preserves original value' do
+          @taggable.language_list_was.should == "awesome, epic"
+        end
+
+        it 'shows what the change was' do
+          @taggable.language_list_change.should == ["awesome, epic", ["one"]]
+        end
+
+        it 'shows what the changes were' do
+          @taggable.language_list_changes.should == ["awesome, epic", ["one"]]
+        end
+      end
+
+      context 'when language_list is the same' do
+        before(:each) do
+          @taggable.language_list = "awesome, epic"
+        end
+
+        it 'is not flagged as changed' do
+          @taggable.language_list_changed?.should be_false
+        end
+
+        it 'does not show any changes to the taggable item' do
+          @taggable.changes.should == {}
+        end
+      end
     end
   end