acts_as_taggable_on 3.0.0.rc1

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe "acts_as_tagger" do
+  before(:each) do
+    clean_database!
+  end
+
+  describe "Tagger Method Generation" do
+    before(:each) do
+      @tagger = User.new
+    end
+
+    it "should add #is_tagger? query method to the class-side" do
+      User.should respond_to(:is_tagger?)
+    end
+
+    it "should return true from the class-side #is_tagger?" do
+      User.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 = User.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 => :tags)
+        @taggable.tag_list.should == %w(ruby python)
+        @tagger.tag(@taggable, :with => '', :on => :tags)
+        @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
+
+    describe "when called by multiple tagger's" do
+      before(:each) do
+        @user_x = User.create(:name => "User X")
+        @user_y = User.create(:name => "User Y")
+        @taggable = TaggableModel.create(:name => 'acts_as_taggable_on', :tag_list => 'plugin')
+
+        @user_x.tag(@taggable, :with => 'ruby, rails',  :on => :tags)
+        @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/caching_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe "Acts As Taggable On" do
+
+  before(:each) do
+    clean_database!
+  end
+
+  describe 'Caching' do
+    before(:each) do
+      @taggable = CachedModel.new(:name => "Bob Jones")
+      @another_taggable = OtherCachedModel.new(:name => "John Smith")
+    end
+
+    it "should add saving of tag lists and cached tag lists to the instance" do
+      @taggable.should respond_to(:save_cached_tag_list)
+      @another_taggable.should respond_to(:save_cached_tag_list)
+
+      @taggable.should respond_to(:save_tags)
+    end
+
+    it "should add cached tag lists to the instance if cached column is not present" do
+      TaggableModel.new(:name => "Art Kram").should_not respond_to(:save_cached_tag_list)
+    end
+
+    it "should generate a cached column checker for each tag type" do
+      CachedModel.should respond_to(:caching_tag_list?)
+      OtherCachedModel.should respond_to(:caching_language_list?)
+    end
+
+    it 'should not have cached tags' do
+      @taggable.cached_tag_list.should be_blank
+      @another_taggable.cached_language_list.should be_blank
+    end
+
+    it 'should cache tags' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable.cached_tag_list.should == 'awesome, epic'
+
+      @another_taggable.update_attributes(:language_list => 'ruby, .net')
+      @another_taggable.cached_language_list.should == 'ruby, .net'
+    end
+
+    it 'should keep the cache' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable = CachedModel.find(@taggable)
+      @taggable.save!
+      @taggable.cached_tag_list.should == 'awesome, epic'
+    end
+
+    it 'should update the cache' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable.update_attributes(:tag_list => 'awesome')
+      @taggable.cached_tag_list.should == 'awesome'
+    end
+
+    it 'should remove the cache' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable.update_attributes(:tag_list => '')
+      @taggable.cached_tag_list.should be_blank
+    end
+
+    it 'should have a tag list' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable = CachedModel.find(@taggable.id)
+      @taggable.tag_list.sort.should == %w(awesome epic).sort
+    end
+
+    it 'should keep the tag list' do
+      @taggable.update_attributes(:tag_list => 'awesome, epic')
+      @taggable = CachedModel.find(@taggable.id)
+      @taggable.save!
+      @taggable.tag_list.sort.should == %w(awesome epic).sort
+    end
+  end
+
+end

data/spec/acts_as_taggable_on/related_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe "Acts As Taggable On" do
+  before(:each) do
+    clean_database!
+  end
+
+  describe "Related Objects" do
+    it "should find related objects based on tag names on context" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = TaggableModel.create!(:name => "Taggable 2")
+      taggable3 = TaggableModel.create!(:name => "Taggable 3")
+
+      taggable1.tag_list = "one, two"
+      taggable1.save
+
+      taggable2.tag_list = "three, four"
+      taggable2.save
+
+      taggable3.tag_list = "one, four"
+      taggable3.save
+
+      taggable1.find_related_tags.should include(taggable3)
+      taggable1.find_related_tags.should_not include(taggable2)
+    end
+
+    it "finds related tags for ordered taggable on" do
+      taggable1 = OrderedTaggableModel.create!(:name => "Taggable 1")
+      taggable2 = OrderedTaggableModel.create!(:name => "Taggable 2")
+      taggable3 = OrderedTaggableModel.create!(:name => "Taggable 3")
+
+      taggable1.colour_list = "one, two"
+      taggable1.save
+
+      taggable2.colour_list = "three, four"
+      taggable2.save
+
+      taggable3.colour_list = "one, four"
+      taggable3.save
+
+      taggable1.find_related_colours.should include(taggable3)
+      taggable1.find_related_colours.should_not include(taggable2)
+    end
+
+    it "should find related objects based on tag names on context - non standard id" do
+      taggable1 = NonStandardIdTaggableModel.create!(:name => "Taggable 1")
+      taggable2 = NonStandardIdTaggableModel.create!(:name => "Taggable 2")
+      taggable3 = NonStandardIdTaggableModel.create!(:name => "Taggable 3")
+
+      taggable1.tag_list = "one, two"
+      taggable1.save
+
+      taggable2.tag_list = "three, four"
+      taggable2.save
+
+      taggable3.tag_list = "one, four"
+      taggable3.save
+
+      taggable1.find_related_tags.should include(taggable3)
+      taggable1.find_related_tags.should_not include(taggable2)
+    end
+
+    it "should find other related objects based on tag names on context" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = OtherTaggableModel.create!(:name => "Taggable 2")
+      taggable3 = OtherTaggableModel.create!(:name => "Taggable 3")
+
+      taggable1.tag_list = "one, two"
+      taggable1.save
+
+      taggable2.tag_list = "three, four"
+      taggable2.save
+
+      taggable3.tag_list = "one, four"
+      taggable3.save
+
+      taggable1.find_related_tags_for(OtherTaggableModel).should include(taggable3)
+      taggable1.find_related_tags_for(OtherTaggableModel).should_not include(taggable2)
+    end
+
+    it "should not include the object itself in the list of related objects" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = TaggableModel.create!(:name => "Taggable 2")
+
+      taggable1.tag_list = "one"
+      taggable1.save
+
+      taggable2.tag_list = "one, two"
+      taggable2.save
+
+      taggable1.find_related_tags.should include(taggable2)
+      taggable1.find_related_tags.should_not include(taggable1)
+    end
+
+    it "should not include the object itself in the list of related objects - non standard id" do
+      taggable1 = NonStandardIdTaggableModel.create!(:name => "Taggable 1")
+      taggable2 = NonStandardIdTaggableModel.create!(:name => "Taggable 2")
+
+      taggable1.tag_list = "one"
+      taggable1.save
+
+      taggable2.tag_list = "one, two"
+      taggable2.save
+
+      taggable1.find_related_tags.should include(taggable2)
+      taggable1.find_related_tags.should_not include(taggable1)
+    end
+
+		context "Ignored Tags" do
+			let(:taggable1) { TaggableModel.create!(:name => "Taggable 1") }
+			let(:taggable2) { TaggableModel.create!(:name => "Taggable 2") }
+			let(:taggable3) { TaggableModel.create!(:name => "Taggable 3") }
+			before(:each) do
+				taggable1.tag_list = "one, two, four"
+				taggable1.save
+
+				taggable2.tag_list = "two, three"
+				taggable2.save
+
+				taggable3.tag_list = "one, three"
+				taggable3.save
+			end
+			it "should not include ignored tags in related search" do
+				taggable1.find_related_tags(:ignore => 'two').should_not include(taggable2)
+				taggable1.find_related_tags(:ignore => 'two').should include(taggable3)
+			end
+
+			it "should accept array of ignored tags" do
+				taggable4 = TaggableModel.create!(:name => "Taggable 4")
+				taggable4.tag_list = "four"
+				taggable4.save
+
+				taggable1.find_related_tags(:ignore => ['two', 'four']).should_not include(taggable2)
+				taggable1.find_related_tags(:ignore => ['two', 'four']).should_not include(taggable4)
+			end
+
+			it "should accept symbols as ignored tags" do
+				taggable1.find_related_tags(:ignore => :two).should_not include(taggable2)
+			end
+		end
+
+  end
+end

data/spec/acts_as_taggable_on/single_table_inheritance_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe "Single Table Inheritance" do
+
+  before(:each) do
+    clean_database!
+  end
+
+  let(:taggable)            { TaggableModel.new(:name => "taggable model") }
+
+  let(:inheriting_model)    { InheritingTaggableModel.new(:name => "Inheriting Taggable Model") }
+  let(:altered_inheriting)  { AlteredInheritingTaggableModel.new(:name => "Altered Inheriting Model") }
+
+  1.upto(4) do |n|
+    let(:"inheriting_#{n}") { InheritingTaggableModel.new(:name => "Inheriting Model #{n}") }
+  end
+
+  let(:student)             { Student.create! }
+
+  describe "tag contexts" do
+    it "should pass on to STI-inherited models" do
+      inheriting_model.should respond_to(:tag_list, :skill_list, :language_list)
+      altered_inheriting.should respond_to(:tag_list, :skill_list, :language_list)
+    end
+
+    it "should pass on to altered STI models" do
+      altered_inheriting.should respond_to(:part_list)
+    end
+  end
+
+  context "matching contexts" do
+
+    before do
+      inheriting_1.offering_list = "one, two"
+      inheriting_1.need_list = "one, two"
+      inheriting_1.save!
+
+      inheriting_2.need_list = "one, two"
+      inheriting_2.save!
+
+      inheriting_3.offering_list = "one, two"
+      inheriting_3.save!
+
+      inheriting_4.tag_list = "one, two, three, four"
+      inheriting_4.save!
+
+      taggable.need_list = "one, two"
+      taggable.save!
+    end
+
+    it "should find objects with tags of matching contexts" do
+      inheriting_1.find_matching_contexts(:offerings, :needs).should      include(inheriting_2)
+      inheriting_1.find_matching_contexts(:offerings, :needs).should_not  include(inheriting_3)
+      inheriting_1.find_matching_contexts(:offerings, :needs).should_not  include(inheriting_4)
+      inheriting_1.find_matching_contexts(:offerings, :needs).should_not  include(taggable)
+
+      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should     include(inheriting_2)
+      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(inheriting_3)
+      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(inheriting_4)
+      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should     include(taggable)
+    end
+
+    it "should not include the object itself in the list of related objects with tags of matching contexts" do
+      inheriting_1.find_matching_contexts(:offerings, :needs).should_not include(inheriting_1)
+      inheriting_1.find_matching_contexts_for(InheritingTaggableModel, :offerings, :needs).should_not include(inheriting_1)
+      inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(inheriting_1)
+    end
+  end
+
+  context "find related tags" do
+    before do
+      inheriting_1.tag_list = "one, two"
+      inheriting_1.save
+
+      inheriting_2.tag_list = "three, four"
+      inheriting_2.save
+
+      inheriting_3.tag_list = "one, four"
+      inheriting_3.save
+
+      taggable.tag_list = "one, two, three, four"
+      taggable.save
+    end
+
+    it "should find related objects based on tag names on context" do
+      inheriting_1.find_related_tags.should include(inheriting_3)
+      inheriting_1.find_related_tags.should_not include(inheriting_2)
+      inheriting_1.find_related_tags.should_not include(taggable)
+
+      inheriting_1.find_related_tags_for(TaggableModel).should include(inheriting_3)
+      inheriting_1.find_related_tags_for(TaggableModel).should_not include(inheriting_2)
+      inheriting_1.find_related_tags_for(TaggableModel).should include(taggable)
+    end
+
+    it "should not include the object itself in the list of related objects" do
+      inheriting_1.find_related_tags.should_not include(inheriting_1)
+      inheriting_1.find_related_tags_for(InheritingTaggableModel).should_not include(inheriting_1)
+      inheriting_1.find_related_tags_for(TaggableModel).should_not include(inheriting_1)
+    end
+  end
+
+  describe "tag list" do
+    before do
+      @inherited_same = InheritingTaggableModel.new(:name => "inherited same")
+      @inherited_different = AlteredInheritingTaggableModel.new(:name => "inherited different")
+    end
+
+    it "should be able to save tags for inherited models" do
+      inheriting_model.tag_list = "bob, kelso"
+      inheriting_model.save
+      InheritingTaggableModel.tagged_with("bob").first.should == inheriting_model
+    end
+
+    it "should find STI tagged models on the superclass" do
+      inheriting_model.tag_list = "bob, kelso"
+      inheriting_model.save
+      TaggableModel.tagged_with("bob").first.should == inheriting_model
+    end
+
+    it "should be able to add on contexts only to some subclasses" do
+      altered_inheriting.part_list = "fork, spoon"
+      altered_inheriting.save
+      InheritingTaggableModel.tagged_with("fork", :on => :parts).should be_empty
+      AlteredInheritingTaggableModel.tagged_with("fork", :on => :parts).first.should == altered_inheriting
+    end
+
+    it "should have different tag_counts_on for inherited models" do
+      inheriting_model.tag_list = "bob, kelso"
+      inheriting_model.save!
+      altered_inheriting.tag_list = "fork, spoon"
+      altered_inheriting.save!
+
+      InheritingTaggableModel.tag_counts_on(:tags, :order => 'tags.id').map(&:name).should == %w(bob kelso)
+      AlteredInheritingTaggableModel.tag_counts_on(:tags, :order => 'tags.id').map(&:name).should == %w(fork spoon)
+      TaggableModel.tag_counts_on(:tags, :order => 'tags.id').map(&:name).should == %w(bob kelso fork spoon)
+    end
+
+    it "should have different tags_on for inherited models" do
+      inheriting_model.tag_list = "bob, kelso"
+      inheriting_model.save!
+      altered_inheriting.tag_list = "fork, spoon"
+      altered_inheriting.save!
+
+      InheritingTaggableModel.tags_on(:tags, :order => 'tags.id').map(&:name).should == %w(bob kelso)
+      AlteredInheritingTaggableModel.tags_on(:tags, :order => 'tags.id').map(&:name).should == %w(fork spoon)
+      TaggableModel.tags_on(:tags, :order => 'tags.id').map(&:name).should == %w(bob kelso fork spoon)
+    end
+
+    it 'should store same tag without validation conflict' do
+      taggable.tag_list = 'one'
+      taggable.save!
+
+      inheriting_model.tag_list = 'one'
+      inheriting_model.save!
+
+      inheriting_model.update_attributes! :name => 'foo'
+    end
+  end
+
+  describe "ownership" do
+    it "should have taggings" do
+      student.tag(taggable, :with=>'ruby,scheme', :on=>:tags)
+      student.owned_taggings.should have(2).tags
+    end
+
+    it "should have tags" do
+      student.tag(taggable, :with=>'ruby,scheme', :on=>:tags)
+      student.owned_tags.should have(2).tags
+    end
+
+    it "should return tags for the inheriting tagger" do
+      student.tag(taggable, :with => 'ruby, scheme', :on => :tags)
+      taggable.tags_from(student).should match_array(%w(ruby scheme))
+    end
+
+    it "returns owner tags on the tagger" do
+      student.tag(taggable, :with => 'ruby, scheme', :on => :tags)
+      taggable.owner_tags_on(student, :tags).should have(2).tags
+    end
+
+    it "should scope objects returned by tagged_with by owners" do
+      student.tag(taggable, :with => 'ruby, scheme', :on => :tags)
+      TaggableModel.tagged_with(%w(ruby scheme), :owned_by => student).should have(1).tag
+    end
+  end
+
+end