acts-as-taggable-on 0.0.0 → 1.0.6

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -1,11 +1,8 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe "acts_as_tagger" do
-  before(:each) do
-    clean_database!
-  end
-  
   context "Tagger Method Generation" do
+
     before(:each) do
       @tagger = TaggableUser.new()
     end
@@ -51,23 +48,8 @@ describe "acts_as_tagger" do
       
       it 'should by default create the tag context on-the-fly' do
         @taggable.tag_list_on(:here_ond_now).should be_empty
-        @tagger.tag(@taggable, :with=>'that', :on => :here_ond_now)
-        @taggable.tag_list_on(:here_ond_now).should_not include('that')
-        @taggable.all_tags_list_on(:here_ond_now).should include('that')
-      end
-      
-      it "should show all the tag list when both public and owned tags exist" do
-        @taggable.tag_list = 'ruby, python'
-        @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
-        @taggable.all_tags_on(:tags).map(&:name).sort.should == %w(ruby python java lisp).sort
-      end
-      
-      it "should not add owned tags to the common list" do
-        @taggable.tag_list = 'ruby, python'
-        @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
-        @taggable.tag_list.should == %w(ruby python)
-        @tagger.tag(@taggable, :with => '', :on => :tags)
-        @taggable.tag_list.should == %w(ruby python)
+        @tagger.tag(@taggable, :with=>'that', :on=>:here_ond_now)
+        @taggable.tag_list_on(:here_ond_now).should include('that')
       end
       
       it "should throw an exception when the default is over-ridden" do
@@ -82,33 +64,9 @@ describe "acts_as_tagger" do
         @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo_boo, :force=>false) rescue
         @taggable.tag_list_on(:foo_boo).should be_empty
       end
-    end
-    
-    context "when called by multiple tagger's" do
-      before(:each) do
-        @user_x = TaggableUser.create(:name => "User X")
-        @user_y = TaggableUser.create(:name => "User Y")
-        @taggable = TaggableModel.create(:name => 'acts_as_taggable_on', :tag_list => 'plugin')
-        
-        @user_x.tag(@taggable, :with => 'ruby, rails',  :on => :tags)
-        @user_y.tag(@taggable, :with => 'ruby, plugin', :on => :tags)
 
-        @user_y.tag(@taggable, :with => '', :on => :tags)
-        @user_y.tag(@taggable, :with => '', :on => :tags)
-      end
-      
-      it "should delete owned tags" do        
-        @user_y.owned_tags.should == []
-      end
-      
-      it "should not delete other taggers tags" do
-        @user_x.owned_tags.should have(2).items
-      end
-      
-      it "should not delete original tags" do
-        @taggable.all_tags_list_on(:tags).should include('plugin')
-      end
     end
+  
   end
 
 end

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -20,24 +20,6 @@ describe TagList do
     @tag_list.include?("wicked").should be_true
   end
   
-  it "should be able to add delimited list of words with quoted delimiters" do
-    @tag_list.add("'cool, wicked', \"really cool, really wicked\"", :parse => true)
-    @tag_list.include?("cool, wicked").should be_true
-    @tag_list.include?("really cool, really wicked").should be_true
-  end
-  
-  it "should be able to handle other uses of quotation marks correctly" do
-    @tag_list.add("john's cool car, mary's wicked toy", :parse => true)
-    @tag_list.include?("john's cool car").should be_true
-    @tag_list.include?("mary's wicked toy").should be_true
-  end
-  
-  it "should be able to add an array of words" do
-    @tag_list.add(["cool", "wicked"], :parse => true)
-    @tag_list.include?("cool").should be_true
-    @tag_list.include?("wicked").should be_true
-  end
-  
   it "should be able to remove words" do
     @tag_list.remove("awesome")
     @tag_list.include?("awesome").should be_false
@@ -48,11 +30,6 @@ describe TagList do
     @tag_list.should be_empty
   end
   
-  it "should be able to remove an array of words" do
-    @tag_list.remove(["awesome", "radical"], :parse => true)
-    @tag_list.should be_empty
-  end
-  
   it "should give a delimited list of words when converted to string" do
     @tag_list.to_s.should == "awesome, radical"
   end
@@ -61,10 +38,4 @@ describe TagList do
     @tag_list.add("cool","rad,bodacious")
     @tag_list.to_s.should == "awesome, radical, cool, \"rad,bodacious\""
   end
-  
-  it "should be able to call to_s on a frozen tag list" do
-    @tag_list.freeze
-    lambda { @tag_list.add("cool","rad,bodacious") }.should raise_error
-    lambda { @tag_list.to_s }.should_not raise_error
-  end
 end

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -2,114 +2,26 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Tag do
   before(:each) do
-    clean_database!
     @tag = Tag.new
-    @user = TaggableModel.create(:name => "Pablo")
+    @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")
-      }.should change(Tag, :count).by(1)
-    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?
-    
-    if ActiveRecord::VERSION::MAJOR >= 3
-      @tag.errors[:name].should == ["can't be blank"]
-    else
-      @tag.errors[:name].should == "can't be blank"
-    end
-
+    @tag.errors.on(:name).should == "can't be blank"
     @tag.name = "something"
     @tag.valid?
-    
-    if ActiveRecord::VERSION::MAJOR >= 3      
-      @tag.errors[:name].should == []
-    else
-      @tag.errors[:name].should be_nil
-    end
+    @tag.errors.on(:name).should be_nil
   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,58 +2,34 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe "Taggable" do
   before(:each) do
-    clean_database!
+    [TaggableModel, Tag, Tagging, TaggableUser].each(&:delete_all)
     @taggable = TaggableModel.new(:name => "Bob Jones")
   end
-
-  it "should have tag types" do
-    [: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).all.should be_empty
-
-    @taggable.tag_list = ["awesome", "epic"]
-    @taggable.save
-
-    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
     
-    lambda {
-      @taggable.save
-    }.should change(Tag, :count).by(3)
+    Tag.find(:all).size.should == 3
   end
-
+  
   it "should be able to create tags through the tag list directly" do
     @taggable.tag_list_on(:test).add("hello")
-    @taggable.tag_list_cache_on(:test).should_not be_empty
-    @taggable.tag_list_on(:test).should == ["hello"]
-    
-    @taggable.save
-    @taggable.save_tags
-    
+    @taggable.save    
     @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.should include("ruby")
-    @taggable.skill_list.should_not include("bob")
+    @taggable.skill_list.include?("ruby").should be_true
+    @taggable.skill_list.include?("bob").should be_false
   end
-
+  
   it "should be able to remove tags through list alone" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.save
@@ -64,83 +40,55 @@ 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.tagged_with("ruby").first.should == @taggable
+    TaggableModel.find_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.tagged_with("ruby").first.should == @taggable
-    TaggableModel.tagged_with("ruby, css").first.should == @taggable
+    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("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.tagged_with("ruby").to_a.should == TaggableModel.tagged_with("Ruby").to_a
+    TaggableModel.find_tagged_with("ruby").should == TaggableModel.find_tagged_with("Ruby")
   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.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
-    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.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
+  
+  it "should be able to get tag counts on an association" 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
+    bob.tag_counts.first.count.should == 2
+    charlie.skill_counts.first.count.should == 1
   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")
@@ -149,83 +97,26 @@ 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.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.tagged_with("spinning", :on => :rotors).to_a.should == [bob]
+    TaggableModel.find_tagged_with("spinning", :on => :rotors).should_not be_empty
   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').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.tagged_with("fitter, happier", :match_all => true).to_a.should == [steve]
+    TaggableModel.tagged_with('rails', :on => :skills).all(:order => 'taggable_models.name').should == [bob, frank]
+    TaggableModel.tagged_with('happier', :on => :tags).all(:order => 'taggable_models.name').should == [bob, steve]
+    TaggableModel.tagged_with('rails', :on => :skills).tagged_with('happier', :on => :tags).should == [bob]
   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 "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)
@@ -233,45 +124,24 @@ describe "Taggable" 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
       @inherited_same.tag_list = "bob, kelso"
       @inherited_same.save
-      InheritingTaggableModel.tagged_with("bob").first.should == @inherited_same
+      InheritingTaggableModel.find_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
+      TaggableModel.find_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).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'
+      InheritingTaggableModel.find_tagged_with("fork", :on => :parts).should be_empty
+      AlteredInheritingTaggableModel.find_tagged_with("fork", :on => :parts).first.should == @inherited_different
     end
   end
 end