acts-as-taggable-on 1.0.13 → 2.0.6

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -1,50 +1,62 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path('../../spec_helper', __FILE__)
 
 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
+    @taggable.instance_variable_get("@skill_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
     
-    Tag.find(:all).size.should == 3
+    lambda {
+      @taggable.save
+    }.should change(ActsAsTaggableOn::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,98 @@ 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")
+
+    ActsAsTaggableOn::Tag.find(:all).size.should == 1
+    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.all.should_not be_empty
+    TaggableModel.all_tag_counts(:order => 'tags.id').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
     
-    TaggableModel.all_tag_counts.should_not be_empty
-    TaggableModel.all_tag_counts.first.count.should == 3 # ruby
+    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").tag_counts(:order => 'tags.id').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(:order => 'tags.id').first.count.should == 3 # ruby
+  end
+
+  it 'should only return tag counts for the available scope' 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, java")
+ 
+    TaggableModel.tagged_with('rails').all_tag_counts.should have(3).items
+    TaggableModel.tagged_with('rails').all_tag_counts.any? { |tag| tag.name == 'java' }.should be_false
     
-    TaggableModel.tagged_with("ruby").all_tag_counts.first.count.should == 3 # ruby
+    # 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
   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 +167,150 @@ 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 quotation marks" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive, 'I love the ,comma,'")
+    TaggableModel.tagged_with("'I love the ,comma,'").should include(bob)
   end
   
+  it "should be able to find tagged with invalid tags" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive")    
+    TaggableModel.tagged_with("sad, happier").should_not include(bob)    
+  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(ActsAsTaggableOn::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(ActsAsTaggableOn::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)
+  
+      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 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

@@ -1,22 +1,90 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path('../../spec_helper', __FILE__)
 
 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(ActsAsTaggableOn::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(ActsAsTaggableOn::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(ActsAsTaggableOn::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(ActsAsTaggableOn::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

@@ -1,16 +1,31 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path('../../spec_helper', __FILE__)
 
-describe Tagging do
+describe ActsAsTaggableOn::Tagging do
   before(:each) do
-    @tagging = Tagging.new
+    clean_database!
+    @tagging = ActsAsTaggableOn::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.tag = ActsAsTaggableOn::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 = ActsAsTaggableOn::Tag.create(:name => "awesome")
+
+    lambda {
+      2.times { ActsAsTaggableOn::Tagging.create(:taggable => @taggable, :tag => @tag, :context => 'tags') }
+    }.should change(ActsAsTaggableOn::Tagging, :count).by(1)
   end
-end
+end

data/spec/acts_as_taggable_on/tags_helper_spec.rb

@@ -1,18 +1,16 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path('../../spec_helper', __FILE__)
 
-describe TagsHelper do
+describe ActsAsTaggableOn::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")
     @eve = TaggableModel.create(:name => "Eve Nodd",   :language_list => "ruby, c++")
     
     @helper = class Helper
-      include TagsHelper
+      include ActsAsTaggableOn::TagsHelper
     end.new
-    
-    
   end
   
   it "should yield the proper css classes" do 

data/spec/bm.rb

@@ -0,0 +1,52 @@
+require 'active_record'
+require 'action_view'
+require File.expand_path('../../lib/acts-as-taggable-on', __FILE__)
+
+if defined?(ActiveRecord::Acts::TaggableOn)
+  ActiveRecord::Base.send :include, ActiveRecord::Acts::TaggableOn
+  ActiveRecord::Base.send :include, ActiveRecord::Acts::Tagger
+  ActionView::Base.send :include, TagsHelper if defined?(ActionView::Base)
+end
+
+TEST_DATABASE_FILE = File.join(File.dirname(__FILE__), '..', 'test.sqlite3')
+File.unlink(TEST_DATABASE_FILE) if File.exist?(TEST_DATABASE_FILE)
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => TEST_DATABASE_FILE
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Schema.define :version => 0 do
+    create_table "taggings", :force => true do |t|
+      t.integer  "tag_id",        :limit => 11
+      t.integer  "taggable_id",   :limit => 11
+      t.string   "taggable_type"
+      t.string   "context"
+      t.datetime "created_at"
+      t.integer  "tagger_id",     :limit => 11
+      t.string   "tagger_type"
+    end
+
+    add_index "taggings", ["tag_id"], :name => "index_taggings_on_tag_id"
+    add_index "taggings", ["taggable_id", "taggable_type", "context"], :name => "index_taggings_on_taggable_id_and_taggable_type_and_context"
+
+    create_table "tags", :force => true do |t|
+      t.string "name"
+    end
+
+    create_table :taggable_models, :force => true do |t|
+      t.column :name, :string
+      t.column :type, :string
+      t.column :cached_tag_list, :string
+    end
+  end
+
+  class TaggableModel < ActiveRecord::Base
+    acts_as_taggable
+    acts_as_taggable_on :languages
+    acts_as_taggable_on :skills
+    acts_as_taggable_on :needs, :offerings
+  end
+end
+
+puts Benchmark.measure {
+  1000.times { TaggableModel.create :tag_list => "awesome, epic, neat" }
+}

data/spec/database.yml

@@ -0,0 +1,17 @@
+sqlite3:
+  adapter: sqlite3
+  database: acts_as_taggable_on.sqlite3
+
+mysql:
+  adapter: mysql
+  hostname: localhost
+  username: root
+  password:
+  database: acts_as_taggable_on
+
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: acts_as_taggable_on

data/spec/database.yml.sample

@@ -0,0 +1,17 @@
+sqlite3:
+  adapter: sqlite3
+  database: acts_as_taggable_on.sqlite3
+
+mysql:
+  adapter: mysql
+  hostname: localhost
+  username: root
+  password:
+  database: acts_as_taggable_on
+
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: acts_as_taggable_on

data/spec/models.rb

@@ -0,0 +1,31 @@
+class TaggableModel < ActiveRecord::Base
+  acts_as_taggable
+  acts_as_taggable_on :languages
+  acts_as_taggable_on :skills
+  acts_as_taggable_on :needs, :offerings
+  has_many :untaggable_models
+end
+
+class CachedModel < ActiveRecord::Base
+  acts_as_taggable
+end
+
+class OtherTaggableModel < ActiveRecord::Base
+  acts_as_taggable_on :tags, :languages
+  acts_as_taggable_on :needs, :offerings
+end
+
+class InheritingTaggableModel < TaggableModel
+end
+
+class AlteredInheritingTaggableModel < TaggableModel
+  acts_as_taggable_on :parts
+end
+
+class TaggableUser < ActiveRecord::Base
+  acts_as_tagger
+end
+
+class UntaggableModel < ActiveRecord::Base
+  belongs_to :taggable_model
+end