acts-as-taggable-on 1.0.19 → 1.1.0

data/VERSION

@@ -1 +1 @@
-1.0.19
+1.1.0

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -82,7 +82,6 @@ module ActiveRecord
               end
             RUBY
           end
-
           if respond_to?(:tag_types)
             write_inheritable_attribute( :tag_types, (tag_types + args).uniq )
           else
@@ -286,29 +285,40 @@ module ActiveRecord
         def is_taggable?
           self.class.is_taggable?
         end
-
+        
         def add_custom_context(value)
           custom_contexts << value.to_s unless custom_contexts.include?(value.to_s) or self.class.tag_types.map(&:to_s).include?(value.to_s)
         end
 
-        def tag_list_on(context, owner=nil)
-          var_name = context.to_s.singularize + "_list"
+        def tag_list_on(context, owner = nil)
           add_custom_context(context)
-          return instance_variable_get("@#{var_name}") unless instance_variable_get("@#{var_name}").nil?
-
+          cache = tag_list_cache_on(context)
+          return owner ? cache[owner] : cache[owner] if cache[owner]
+          
           if !owner && self.class.caching_tag_list_on?(context) and !(cached_value = cached_tag_list_on(context)).nil?
-            instance_variable_set("@#{var_name}", TagList.from(self["cached_#{var_name}"]))
+            cache[owner] = TagList.from(cached_tag_list_on(context))
           else
-            instance_variable_set("@#{var_name}", TagList.new(*tags_on(context, owner).map(&:name)))
+            cache[owner] = TagList.new(*tags_on(context, owner).map(&:name))
           end
         end
+        
+        def all_tags_list_on(context)
+          variable_name = "@all_#{context.to_s.singularize}_list"
+          return instance_variable_get(variable_name) if instance_variable_get(variable_name)
+          instance_variable_set(variable_name, TagList.new(all_tags_on(context).map(&:name)).freeze)
+        end
+        
+        def all_tags_on(context)
+          opts = {:conditions => ["#{Tagging.table_name}.context = ?", context.to_s]}
+          base_tags.find(:all, opts.merge(:order => "#{Tagging.table_name}.created_at"))
+        end
 
-        def tags_on(context, owner=nil)
+        def tags_on(context, owner = nil)
           if owner
             opts = {:conditions => ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id = ? AND #{Tagging.table_name}.tagger_type = ?",
                                     context.to_s, owner.id, owner.class.to_s]}
           else
-            opts = {:conditions => ["#{Tagging.table_name}.context = ?", context.to_s]}
+            opts = {:conditions => ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id IS NULL", context.to_s]}
           end
           base_tags.find(:all, opts)
         end
@@ -316,9 +326,16 @@ module ActiveRecord
         def cached_tag_list_on(context)
           self["cached_#{context.to_s.singularize}_list"]
         end
+        
+        def tag_list_cache_on(context)
+          variable_name = "@#{context.to_s.singularize}_list"
+          cache = instance_variable_get(variable_name)
+          instance_variable_set(variable_name, cache = {}) unless cache
+          cache
+        end
 
-        def set_tag_list_on(context,new_list, tagger=nil)
-          instance_variable_set("@#{context.to_s.singularize}_list", TagList.from_owner(tagger, new_list))
+        def set_tag_list_on(context, new_list, tagger = nil)
+          tag_list_cache_on(context)[tagger] = TagList.from(new_list)
           add_custom_context(context)
         end
 
@@ -367,24 +384,24 @@ module ActiveRecord
         def save_cached_tag_list
           self.class.tag_types.map(&:to_s).each do |tag_type|
             if self.class.send("caching_#{tag_type.singularize}_list?")
-              self["cached_#{tag_type.singularize}_list"] = send("#{tag_type.singularize}_list").to_s
+              self["cached_#{tag_type.singularize}_list"] = tag_list_cache_on(tag_type.singularize).tags.join(', ')
             end
           end
         end
 
         def save_tags
           (custom_contexts + self.class.tag_types.map(&:to_s)).each do |tag_type|
-            next unless instance_variable_get("@#{tag_type.singularize}_list")
-            owner = instance_variable_get("@#{tag_type.singularize}_list").owner
-            new_tag_names = instance_variable_get("@#{tag_type.singularize}_list") - tags_on(tag_type).map(&:name)
-            old_tags = tags_on(tag_type, owner).reject { |tag| instance_variable_get("@#{tag_type.singularize}_list").include?(tag.name) }
-
-            transaction do
-              base_tags.delete(*old_tags) if old_tags.any?
-              new_tag_names.each do |new_tag_name|
-                new_tag = Tag.find_or_create_with_like_by_name(new_tag_name)
-                Tagging.create(:tag_id => new_tag.id, :context => tag_type,
-                               :taggable => self, :tagger => owner)
+            tag_list_cache = tag_list_cache_on(tag_type)
+            for owner,  tag_list in tag_list_cache
+              new_tag_names = tag_list - tags_on(tag_type, owner).map(&:name)
+              old_tags = tags_on(tag_type, owner).reject { |tag| tag_list.include?(tag.name) }
+              transaction do
+                base_tags.delete(*old_tags) if old_tags.any?
+                new_tag_names.each do |new_tag_name|
+                  new_tag = Tag.find_or_create_with_like_by_name(new_tag_name)
+                  Tagging.create(:tag_id => new_tag.id, :context => tag_type,
+                                 :taggable => self, :tagger => owner)
+                end
               end
             end
           end

data/lib/acts_as_taggable_on/tag_list.rb

@@ -86,11 +86,5 @@ class TagList < Array
         tag_list.add(string.split(delimiter))
       end
     end
-    
-    def from_owner(owner, *tags)
-      returning from(*tags) do |taglist|
-        taglist.owner = owner
-      end
-    end
   end
 end

data/lib/acts_as_taggable_on/tagging.rb

@@ -10,5 +10,5 @@ class Tagging < ActiveRecord::Base #:nodoc:
   validates_presence_of :context
   validates_presence_of :tag_id
   
-  validates_uniqueness_of :tag_id, :scope => [:taggable_type, :taggable_id, :context]
+  validates_uniqueness_of :tag_id, :scope => [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
 end

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -48,8 +48,22 @@ 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 include('that')
+        @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

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -64,7 +64,7 @@ describe TagList do
   
   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(TypeError)
-    lambda { @tag_list.to_s }.should_not raise_error(TypeError)
+    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/taggable_spec.rb

@@ -7,35 +7,40 @@ describe "Taggable" do
   end
 
   it "should have tag types" do
-    TaggableModel.tag_types.should == [:tags, :languages, :skills, :needs, :offerings]
-    @taggable.tag_types.should == TaggableModel.tag_types
+      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).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
   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.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.save    
+    @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"
@@ -44,7 +49,7 @@ describe "Taggable" do
     @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
@@ -55,13 +60,13 @@ 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
   end
-  
+
   it "should be able to find by tag with context" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.tag_list = "bob, charlie"
@@ -70,27 +75,27 @@ describe "Taggable" do
     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("ruby, nonexistingtag").should be_empty
     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")
   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")
@@ -98,39 +103,39 @@ describe "Taggable" do
     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.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")
@@ -139,12 +144,12 @@ 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]    
@@ -154,12 +159,12 @@ describe "Taggable" 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", "java"], :order => 'taggable_models.name', :any => true).should == [bob, frank, steve]
     TaggableModel.find_tagged_with(["c++", "fitter"], :order => 'taggable_models.name', :any => true).should == [bob, steve]
     TaggableModel.find_tagged_with(["depressed", "css"], :order => 'taggable_models.name', :any => true).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")
@@ -172,29 +177,38 @@ describe "Taggable" 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.find_tagged_with("fitter, happier", :match_all => true).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.find_tagged_with("lazy", :exclude => true).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
@@ -203,32 +217,32 @@ 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.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.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.find_tagged_with("fork", :on => :parts).should be_empty
       AlteredInheritingTaggableModel.find_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)

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -6,17 +6,32 @@ describe "Tagger" do
     @user = TaggableUser.new
     @taggable = TaggableModel.new(: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 or lose tags from different users" 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.owned_tags.map(&:name).should == %w(ruby scheme)
+    @user2.owned_tags.map(&:name).sort.should == %w(java python lisp ruby).sort
+    @taggable.tags_from(@user).should == %w(ruby scheme)
+    @taggable.tags_from(@user2).should == %w(java python lisp ruby)
+    @taggable.all_tags_list_on(:tags).sort.should == %w(ruby scheme java python lisp).sort
+    @taggable.all_tags_on(:tags).size.should == 6
+  end
+
   it "is tagger" do
     @user.is_tagger?.should(be_true)
   end  

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-taggable-on
 version: !ruby/object:Gem::Version 
-  version: 1.0.19
+  version: 1.1.0
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-21 00:00:00 -05:00
+date: 2010-02-03 00:00:00 +01:00
 default_executable: 
 dependencies: []