acts-as-taggable-on 1.0.13 → 2.0.0

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -2,25 +2,36 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Tag do
   before(:each) do
+    clean_database!
     @tag = Tag.new
-    @user = TaggableModel.create(:name => "Pablo")  
-    Tag.delete_all
+    @user = TaggableModel.create(:name => "Pablo")
   end
-  
+
+  describe "named like any" do
+    before(:each) do
+      Tag.create(:name => "awesome")
+      Tag.create(:name => "epic")
+    end
+
+    it "should find both tags" do
+      Tag.named_like_any(["awesome", "epic"]).should have(2).items
+    end
+  end
+
   describe "find or create by name" do
     before(:each) do
       @tag.name = "awesome"
       @tag.save
     end
-    
+
     it "should find by name" do
       Tag.find_or_create_with_like_by_name("awesome").should == @tag
     end
-    
+
     it "should find by name case insensitive" do
       Tag.find_or_create_with_like_by_name("AWESOME").should == @tag
     end
-    
+
     it "should create by name" do
       lambda {
         Tag.find_or_create_with_like_by_name("epic")
@@ -28,35 +39,77 @@ describe Tag do
     end
   end
 
+  describe "find or create all by any name" do
+    before(:each) do
+      @tag.name = "awesome"
+      @tag.save
+    end
+
+    it "should find by name" do
+      Tag.find_or_create_all_with_like_by_name("awesome").should == [@tag]
+    end
+
+    it "should find by name case insensitive" do
+      Tag.find_or_create_all_with_like_by_name("AWESOME").should == [@tag]
+    end
+
+    it "should create by name" do
+      lambda {
+        Tag.find_or_create_all_with_like_by_name("epic")
+      }.should change(Tag, :count).by(1)
+    end
+
+    it "should find or create by name" do
+      lambda {
+        Tag.find_or_create_all_with_like_by_name("awesome", "epic").map(&:name).should == ["awesome", "epic"]
+      }.should change(Tag, :count).by(1)
+    end
+
+    it "should return an empty array if no tags are specified" do
+      Tag.find_or_create_all_with_like_by_name([]).should == []
+    end
+  end
+
   it "should require a name" do
     @tag.valid?
-    @tag.errors.on(:name).should == "can't be blank"
+    
+    if ActiveRecord::VERSION::MAJOR >= 3
+      @tag.errors[:name].should == ["can't be blank"]
+    else
+      @tag.errors[:name].should == "can't be blank"
+    end
+
     @tag.name = "something"
     @tag.valid?
-    @tag.errors.on(:name).should be_nil
+    
+    if ActiveRecord::VERSION::MAJOR >= 3      
+      @tag.errors[:name].should == []
+    else
+      @tag.errors[:name].should be_nil
+    end
   end
-  
+
   it "should equal a tag with the same name" do
     @tag.name = "awesome"
     new_tag = Tag.new(:name => "awesome")
     new_tag.should == @tag
   end
-  
+
   it "should return its name when to_s is called" do
     @tag.name = "cool"
     @tag.to_s.should == "cool"
   end
-  
+
   it "have named_scope named(something)" do
     @tag.name = "cool"
     @tag.save!
     Tag.named('cool').should include(@tag)
   end
-  
+
   it "have named_scope named_like(something)" do
     @tag.name = "cool"
     @tag.save!
     @another_tag = Tag.create!(:name => "coolip")
     Tag.named_like('cool').should include(@tag, @another_tag)
   end
-end
+end

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -2,49 +2,61 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe "Taggable" do
   before(:each) do
-    [TaggableModel, Tag, Tagging, TaggableUser].each(&:delete_all)
+    clean_database!
     @taggable = TaggableModel.new(:name => "Bob Jones")
   end
 
   it "should have tag types" do
-    TaggableModel.tag_types.should == [:tags, :languages, :skills, :needs, :offerings]
+    [:tags, :languages, :skills, :needs, :offerings].each do |type|
+      TaggableModel.tag_types.should include type
+    end
+
     @taggable.tag_types.should == TaggableModel.tag_types
   end
 
   it "should have tag_counts_on" do
-    TaggableModel.tag_counts_on(:tags).should be_empty
-    
+    TaggableModel.tag_counts_on(:tags).all.should be_empty
+
     @taggable.tag_list = ["awesome", "epic"]
     @taggable.save
 
-    TaggableModel.tag_counts_on(:tags).count.should == 2
-    @taggable.tag_counts_on(:tags).count.should == 2
+    TaggableModel.tag_counts_on(:tags).length.should == 2
+    @taggable.tag_counts_on(:tags).length.should == 2
   end
-  
+
   it "should be able to create tags" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.instance_variable_get("@skill_list").instance_of?(TagList).should be_true
-    @taggable.save
     
-    Tag.find(:all).size.should == 3
+    lambda {
+      @taggable.save
+    }.should change(Tag, :count).by(3)
+    
+    @taggable.reload
+    @taggable.skill_list.sort.should == %w(ruby rails css).sort
   end
-  
+
   it "should be able to create tags through the tag list directly" do
     @taggable.tag_list_on(:test).add("hello")
-    @taggable.save    
+    @taggable.tag_list_cache_on(:test).should_not be_empty
+    @taggable.tag_list_on(:test).should == ["hello"]
+    
+    @taggable.save
+    @taggable.save_tags
+    
     @taggable.reload
     @taggable.tag_list_on(:test).should == ["hello"]
   end
-  
+
   it "should differentiate between contexts" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.tag_list = "ruby, bob, charlie"
     @taggable.save
     @taggable.reload
-    @taggable.skill_list.include?("ruby").should be_true
-    @taggable.skill_list.include?("bob").should be_false
+    @taggable.skill_list.should include("ruby")
+    @taggable.skill_list.should_not include("bob")
   end
-  
+
   it "should be able to remove tags through list alone" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.save
@@ -55,74 +67,83 @@ describe "Taggable" do
     @taggable.reload
     @taggable.should have(2).skills
   end
-  
+
   it "should be able to find by tag" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.save
-    TaggableModel.find_tagged_with("ruby").first.should == @taggable
+
+    TaggableModel.tagged_with("ruby").first.should == @taggable
   end
-  
+
   it "should be able to find by tag with context" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.tag_list = "bob, charlie"
     @taggable.save
-    TaggableModel.find_tagged_with("ruby").first.should == @taggable
-    TaggableModel.find_tagged_with("bob", :on => :skills).first.should_not == @taggable
-    TaggableModel.find_tagged_with("bob", :on => :tags).first.should == @taggable
-  end
-  
-  it "should be able to use the tagged_with named scope" do
-    @taggable.skill_list = "ruby, rails, css"
-    @taggable.tag_list = "bob, charlie"
-    @taggable.save
-    
+
     TaggableModel.tagged_with("ruby").first.should == @taggable
+    TaggableModel.tagged_with("ruby, css").first.should == @taggable
     TaggableModel.tagged_with("bob", :on => :skills).first.should_not == @taggable
     TaggableModel.tagged_with("bob", :on => :tags).first.should == @taggable
   end
-  
+
   it "should not care about case" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "Ruby")
-    
+
     Tag.find(:all).size.should == 1
-    TaggableModel.find_tagged_with("ruby").should == TaggableModel.find_tagged_with("Ruby")
+    TaggableModel.tagged_with("ruby").to_a.should == TaggableModel.tagged_with("Ruby").to_a
   end
-  
+
   it "should be able to get tag counts on model as a whole" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
     charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
-    TaggableModel.tag_counts.should_not be_empty
-    TaggableModel.skill_counts.should_not be_empty
+    TaggableModel.tag_counts.all.should_not be_empty
+    TaggableModel.skill_counts.all.should_not be_empty
   end
-  
+
   it "should be able to get all tag counts on model as whole" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
     charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
-    
-    TaggableModel.all_tag_counts.should_not be_empty
+
+    TaggableModel.all_tag_counts.all.should_not be_empty
     TaggableModel.all_tag_counts.first.count.should == 3 # ruby
   end
-  
+
+  if ActiveRecord::VERSION::MAJOR >= 3
+    it "should not return read-only records" do
+      TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+      TaggableModel.tagged_with("ruby").first.should_not be_readonly
+    end
+  else
+    xit "should not return read-only records" do
+      # apparantly, there is no way to set readonly to false in a scope if joins are made
+    end
+    
+    it "should be possible to return writable records" do
+      TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+      TaggableModel.tagged_with("ruby").first(:readonly => false).should_not be_readonly      
+    end
+  end
+
   it "should be able to get scoped tag counts" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
     charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
-    
+
     TaggableModel.tagged_with("ruby").tag_counts.first.count.should == 2   # ruby
     TaggableModel.tagged_with("ruby").skill_counts.first.count.should == 1 # ruby
   end
-  
+
   it "should be able to get all scoped tag counts" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
     charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
-    
+
     TaggableModel.tagged_with("ruby").all_tag_counts.first.count.should == 3 # ruby
   end
-  
+
   it "should be able to set a custom tag context list" do
     bob = TaggableModel.create(:name => "Bob")
     bob.set_tag_list_on(:rotors, "spinning, jumping")
@@ -131,89 +152,140 @@ describe "Taggable" do
     bob.reload
     bob.tags_on(:rotors).should_not be_empty
   end
-  
+
   it "should be able to find tagged" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
     steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
-    
-    TaggableModel.find_tagged_with("ruby", :order => 'taggable_models.name').should == [bob, frank, steve]
-    TaggableModel.find_tagged_with("ruby, rails", :order => 'taggable_models.name').should == [bob, frank]
-    TaggableModel.find_tagged_with(["ruby", "rails"], :order => 'taggable_models.name').should == [bob, frank]    
+
+    TaggableModel.tagged_with("ruby", :order => 'taggable_models.name').to_a.should == [bob, frank, steve]
+    TaggableModel.tagged_with("ruby, rails", :order => 'taggable_models.name').to_a.should == [bob, frank]
+    TaggableModel.tagged_with(["ruby", "rails"], :order => 'taggable_models.name').to_a.should == [bob, frank]
   end
-  
+
+  it "should be able to find tagged with any tag" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
+    steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
+
+    TaggableModel.tagged_with(["ruby", "java"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, frank, steve]
+    TaggableModel.tagged_with(["c++", "fitter"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, steve]
+    TaggableModel.tagged_with(["depressed", "css"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, frank]
+  end
+
   it "should be able to find tagged on a custom tag context" do
     bob = TaggableModel.create(:name => "Bob")
     bob.set_tag_list_on(:rotors, "spinning, jumping")
     bob.tag_list_on(:rotors).should == ["spinning","jumping"]
     bob.save
-    TaggableModel.find_tagged_with("spinning", :on => :rotors).should == [bob]
+
+    TaggableModel.tagged_with("spinning", :on => :rotors).to_a.should == [bob]
   end
 
   it "should be able to use named scopes to chain tag finds" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
     steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, python')
-    
+
     # Let's only find those productive Rails developers
-    TaggableModel.tagged_with('rails', :on => :skills, :order => 'taggable_models.name').should == [bob, frank]
-    TaggableModel.tagged_with('happier', :on => :tags, :order => 'taggable_models.name').should == [bob, steve]
-    TaggableModel.tagged_with('rails', :on => :skills).tagged_with('happier', :on => :tags).should == [bob]
-    TaggableModel.tagged_with('rails').tagged_with('happier', :on => :tags).should == [bob]
+    TaggableModel.tagged_with('rails', :on => :skills, :order => 'taggable_models.name').to_a.should == [bob, frank]
+    TaggableModel.tagged_with('happier', :on => :tags, :order => 'taggable_models.name').to_a.should == [bob, steve]
+    TaggableModel.tagged_with('rails', :on => :skills).tagged_with('happier', :on => :tags).to_a.should == [bob]
+    TaggableModel.tagged_with('rails').tagged_with('happier', :on => :tags).to_a.should == [bob]
   end
-  
+
   it "should be able to find tagged with only the matching tags" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "lazy, happier")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "fitter, happier, inefficient")
     steve = TaggableModel.create(:name => 'Steve', :tag_list => "fitter, happier")
-    
-    TaggableModel.find_tagged_with("fitter, happier", :match_all => true).should == [steve]    
+
+    TaggableModel.tagged_with("fitter, happier", :match_all => true).to_a.should == [steve]
   end
-  
+
   it "should be able to find tagged with some excluded tags" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "happier, lazy")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "happier")
     steve = TaggableModel.create(:name => 'Steve', :tag_list => "happier")
+
+    TaggableModel.tagged_with("lazy", :exclude => true).to_a.should == [frank, steve]
+  end
+
+  it "should not create duplicate taggings" do
+    bob = TaggableModel.create(:name => "Bob")
+    lambda {
+      bob.tag_list << "happier"
+      bob.tag_list << "happier"
+      bob.save
+    }.should change(Tagging, :count).by(1)
+  end
+ 
+  describe "Associations" do
+    before(:each) do
+      @taggable = TaggableModel.create(:tag_list => "awesome, epic")
+    end
     
-    TaggableModel.find_tagged_with("lazy", :exclude => true).should == [frank, steve]    
+    it "should not remove tags when creating associated objects" do
+      @taggable.untaggable_models.create!
+      @taggable.reload
+      @taggable.tag_list.should have(2).items
+    end
   end
-  
+
+  describe "grouped_column_names_for method" do
+    it "should return all column names joined for Tag GROUP clause" do
+      @taggable.grouped_column_names_for(Tag).should == "tags.id, tags.name"
+    end
+
+    it "should return all column names joined for TaggableModel GROUP clause" do
+      @taggable.grouped_column_names_for(TaggableModel).should == "taggable_models.id, taggable_models.name, taggable_models.type"
+    end
+  end
+
   describe "Single Table Inheritance" do
     before do
-      [TaggableModel, Tag, Tagging, TaggableUser].each(&:delete_all)
       @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.find_tagged_with("bob").first.should == @inherited_same
+      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.find_tagged_with("bob").first.should == @inherited_same
+      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.find_tagged_with("fork", :on => :parts).should be_empty
-      AlteredInheritingTaggableModel.find_tagged_with("fork", :on => :parts).first.should == @inherited_different
+      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).map(&:name).should == %w(bob kelso)
       AlteredInheritingTaggableModel.tag_counts_on(:tags).map(&:name).should == %w(fork spoon)
       TaggableModel.tag_counts_on(:tags).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
 end

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -2,21 +2,89 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe "Tagger" do
   before(:each) do
-    [TaggableModel, Tag, Tagging, TaggableUser].each(&:delete_all)
-    @user = TaggableUser.new
-    @taggable = TaggableModel.new(:name => "Bob Jones")
+    clean_database!
+    @user = TaggableUser.create
+    @taggable = TaggableModel.create(:name => "Bob Jones")
   end
-  
+
   it "should have taggings" do
     @user.tag(@taggable, :with=>'ruby,scheme', :on=>:tags)
     @user.owned_taggings.size == 2
   end
-  
+
   it "should have tags" do
     @user.tag(@taggable, :with=>'ruby,scheme', :on=>:tags)
     @user.owned_tags.size == 2
   end
   
+  it "should not overlap tags from different taggers" do
+    @user2 = TaggableUser.new
+    lambda{
+      @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
+      @user2.tag(@taggable, :with => 'java, python, lisp, ruby', :on => :tags)
+    }.should change(Tagging, :count).by(6)
+
+    [@user, @user2, @taggable].each(&:reload)
+
+    @user.owned_tags.map(&:name).sort.should == %w(ruby scheme).sort
+    @user2.owned_tags.map(&:name).sort.should == %w(java python lisp ruby).sort
+    
+    @taggable.tags_from(@user).sort.should == %w(ruby scheme).sort
+    @taggable.tags_from(@user2).sort.should == %w(java lisp python ruby).sort
+    
+    @taggable.all_tags_list.sort.should == %w(ruby scheme java python lisp).sort
+    @taggable.all_tags_on(:tags).size.should == 5
+  end
+  
+  it "should not lose tags from different taggers" do
+    @user2 = TaggableUser.create
+    @user2.tag(@taggable, :with => 'java, python, lisp, ruby', :on => :tags)
+    @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)  
+    
+    lambda {
+      @user2.tag(@taggable, :with => 'java, python, lisp', :on => :tags)
+    }.should change(Tagging, :count).by(-1)
+
+    [@user, @user2, @taggable].each(&:reload)
+    
+    @taggable.tags_from(@user).sort.should == %w(ruby scheme).sort
+    @taggable.tags_from(@user2).sort.should == %w(java python lisp).sort
+    
+    @taggable.all_tags_list.sort.should == %w(ruby scheme java python lisp).sort
+    @taggable.all_tags_on(:tags).length.should == 5
+  end
+
+  it "should not lose tags" do
+    @user2 = TaggableUser.create
+    
+    @user.tag(@taggable, :with => 'awesome', :on => :tags)
+    @user2.tag(@taggable, :with => 'awesome, epic', :on => :tags)
+
+    lambda {
+      @user2.tag(@taggable, :with => 'epic', :on => :tags)
+    }.should change(Tagging, :count).by(-1)
+
+    @taggable.reload  
+    @taggable.all_tags_list.should include('awesome')
+    @taggable.all_tags_list.should include('epic')
+  end
+  
+  it "should not lose tags" do
+    @taggable.update_attributes(:tag_list => 'ruby')
+    @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
+    
+    [@taggable, @user].each(&:reload)
+    @taggable.tag_list.should == %w(ruby)
+    @taggable.all_tags_list.sort.should == %w(ruby scheme).sort
+    
+    lambda {
+      @taggable.update_attributes(:tag_list => "")
+    }.should change(Tagging, :count).by(-1)
+    
+    @taggable.tag_list.should == []
+    @taggable.all_tags_list.sort.should == %w(ruby scheme).sort
+  end
+
   it "is tagger" do
     @user.is_tagger?.should(be_true)
   end  

data/spec/acts_as_taggable_on/tagging_spec.rb

@@ -2,15 +2,30 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Tagging do
   before(:each) do
+    clean_database!
     @tagging = Tagging.new
   end
-  
+
   it "should not be valid with a invalid tag" do
     @tagging.taggable = TaggableModel.create(:name => "Bob Jones")
     @tagging.tag = Tag.new(:name => "")
     @tagging.context = "tags"
 
     @tagging.should_not be_valid
-    @tagging.errors.on(:tag_id).should == "can't be blank"
+    
+    if ActiveRecord::VERSION::MAJOR >= 3
+      @tagging.errors[:tag_id].should == ["can't be blank"]
+    else
+      @tagging.errors[:tag_id].should == "can't be blank"
+    end
+  end
+
+  it "should not create duplicate taggings" do
+    @taggable = TaggableModel.create(:name => "Bob Jones")
+    @tag = Tag.create(:name => "awesome")
+
+    lambda {
+      2.times { Tagging.create(:taggable => @taggable, :tag => @tag, :context => 'tags') }
+    }.should change(Tagging, :count).by(1)
   end
-end
+end

data/spec/acts_as_taggable_on/tags_helper_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe TagsHelper do
   before(:each) do
-    [TaggableModel, Tag, Tagging].each(&:delete_all)
+    clean_database!
     
     @bob = TaggableModel.create(:name => "Bob Jones",  :language_list => "ruby, php")
     @tom = TaggableModel.create(:name => "Tom Marley", :language_list => "ruby, java")
@@ -11,8 +11,6 @@ describe TagsHelper do
     @helper = class Helper
       include TagsHelper
     end.new
-    
-    
   end
   
   it "should yield the proper css classes" do