acts-as-taggable-on-simonwh 2.0.0.pre1

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -0,0 +1,113 @@
+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
+
+    it "should add #is_tagger? query method to the class-side" do
+      TaggableUser.should respond_to(:is_tagger?)
+    end
+    
+    it "should return true from the class-side #is_tagger?" do
+      TaggableUser.is_tagger?.should be_true
+    end
+    
+    it "should return false from the base #is_tagger?" do
+      ActiveRecord::Base.is_tagger?.should be_false
+    end
+    
+    it "should add #is_tagger? query method to the singleton" do
+      @tagger.should respond_to(:is_tagger?)
+    end
+    
+    it "should add #tag method on the instance-side" do
+      @tagger.should respond_to(:tag)
+    end
+    
+    it "should generate an association for #owned_taggings and #owned_tags" do
+      @tagger.should respond_to(:owned_taggings, :owned_tags)
+    end
+  end
+  
+  describe "#tag" do
+    context 'when called with a non-existent tag context' do
+      before(:each) do
+        @tagger = TaggableUser.new()
+        @taggable = TaggableModel.new(:name=>"Richard Prior")
+      end
+      
+      it "should by default not throw an exception " do
+        @taggable.tag_list_on(:foo).should be_empty
+        lambda {
+          @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo)
+        }.should_not raise_error
+      end
+      
+      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 => :foo)
+        @tagger.tag(@taggable, :with => '', :on => :foo)
+        @taggable.tag_list.should == %w(ruby python)
+      end
+      
+      it "should throw an exception when the default is over-ridden" do
+        @taggable.tag_list_on(:foo_boo).should be_empty
+        lambda {
+          @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo_boo, :force=>false)
+        }.should raise_error        
+      end
+
+      it "should not create the tag context on-the-fly when the default is over-ridden" do
+        @taggable.tag_list_on(:foo_boo).should be_empty
+        @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/group_helper_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Group Helper" do
+  before(:each) do
+    clean_database!    
+  end
+
+  describe "grouped_column_names_for method" do
+    before(:each) do
+      @taggable = TaggableModel.new(:name => "Bob Jones")
+    end
+
+    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
+end

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe TagList do
+  before(:each) do
+    @tag_list = TagList.new("awesome","radical")
+  end
+  
+  it "should be an array" do
+    @tag_list.is_a?(Array).should be_true
+  end
+  
+  it "should be able to be add a new tag word" do
+    @tag_list.add("cool")
+    @tag_list.include?("cool").should be_true
+  end
+  
+  it "should be able to add delimited lists 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 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
+  end
+  
+  it "should be able to remove delimited lists of words" do
+    @tag_list.remove("awesome, radical", :parse => true)
+    @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
+  
+  it "should quote escape tags with commas in them" 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

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Tag do
+  before(:each) do
+    clean_database!
+    @tag = Tag.new
+    @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?
+    @tag.errors[:name].should == ["can't be blank"]
+    @tag.name = "something"
+    @tag.valid?
+    @tag.errors[:name].should == []
+  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

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -0,0 +1,253 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Taggable" do
+  before(:each) do
+    clean_database!
+    @taggable = TaggableModel.new(:name => "Bob Jones")
+  end
+
+  it "should have tag types" do
+      for type in [:tags, :languages, :skills, :needs, :offerings]
+        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?(Hash).should be_true
+    @taggable.instance_variable_get("@skill_list")[nil].instance_of?(TagList).should be_true
+    @taggable.save
+
+    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.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.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
+    @taggable.reload
+    @taggable.should have(3).skills
+    @taggable.skill_list = "ruby, rails"
+    @taggable.save
+    @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
+  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.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").all.should == TaggableModel.tagged_with("Ruby").all
+  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
+  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
+
+  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
+
+  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")
+    bob.tag_list_on(:rotors).should == ["spinning","jumping"]
+    bob.save
+    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').all.should == [bob, frank, steve]
+    TaggableModel.tagged_with("ruby, rails", :order => 'taggable_models.name').all.should == [bob, frank]
+    TaggableModel.tagged_with(["ruby", "rails"], :order => 'taggable_models.name').all.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).all.should == [bob, frank, steve]
+    TaggableModel.tagged_with(["c++", "fitter"], :order => 'taggable_models.name', :any => true).all.should == [bob, steve]
+    TaggableModel.tagged_with(["depressed", "css"], :order => 'taggable_models.name', :any => true).all.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).all.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]
+  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).all.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).all.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 "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.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).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