acts-as-taggable-on 1.1.0 → 1.1.1

data/VERSION

@@ -1 +1 @@
-1.1.0
+1.1.1

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -390,21 +390,36 @@ module ActiveRecord
         end
 
         def save_tags
-          (custom_contexts + self.class.tag_types.map(&:to_s)).each do |tag_type|
-            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)
+          contexts = custom_contexts + self.class.tag_types.map(&:to_s)
+
+          transaction do
+            contexts.each do |context|
+              cache = tag_list_cache_on(context)
+            
+              cache.each do |owner, list|
+                new_tags = Tag.find_or_create_all_with_like_by_name(list.uniq)
+
+                # Destroy old taggings:
+                if owner
+                  old_tags = tags_on(context, owner) - new_tags
+                  old_taggings = taggings.find(:all, :conditions => { :tag_id => old_tags, :tagger_id => owner, :tagger_type => owner.class.to_s, :context => context })
+                  old_taggings.each(&:destroy)
+                else                  
+                  old_tags = tags_on(context) - new_tags
+                  base_tags.delete(*old_tags)                
+                end
+                
+                new_tags.reject! { |tag| taggings.any? { |tagging| tagging.tag     == tag   &&
+                                                                   tagging.tagger  == owner &&
+                                                                   tagging.context == context } }
+                
+                # create new taggings:
+                new_tags.each do |tag|
+                  taggings.create!(:tag_id => tag.id, :context => context, :tagger => owner)
                 end
               end
             end
-          end
+          end          
 
           true
         end

data/lib/acts_as_taggable_on/tag.rb

@@ -13,17 +13,29 @@ class Tag < ActiveRecord::Base
   
   ### NAMED SCOPES:
   
-  named_scope :named, lambda { |name| { :conditions => ["name = ?", name] } }
+  named_scope :named, lambda { |name| { :conditions => ["name LIKE ?", name] } }
+  named_scope :named_any, lambda { |list| { :conditions => list.map { |tag| sanitize_sql(["name LIKE ?", tag.to_s]) }.join(" OR ") } }
   named_scope :named_like, lambda { |name| { :conditions => ["name LIKE ?", "%#{name}%"] } }
-  named_scope :named_like_any, lambda { |list| { :conditions => list.map { |tag| sanitize_sql(["name LIKE ?", tag.to_s]) }.join(" OR ") } }
+  named_scope :named_like_any, lambda { |list| { :conditions => list.map { |tag| sanitize_sql(["name LIKE ?", "%#{tag.to_s}%"]) }.join(" OR ") } }
   
-  ### METHODS:
+  ### CLASS METHODS:
   
-  # LIKE is used for cross-database case-insensitivity
   def self.find_or_create_with_like_by_name(name)
-    find(:first, :conditions => ["name LIKE ?", name]) || create(:name => name)
+    named_like(name).first || create(:name => name)
   end
   
+  def self.find_or_create_all_with_like_by_name(*list)
+    list = [list].flatten
+
+    existing_tags = Tag.named_any(list).all
+    new_tag_names = list.reject { |name| existing_tags.any? { |tag| tag.name.downcase == name.downcase } }
+    created_tags  = new_tag_names.map { |name| Tag.create(:name => name) }
+  
+    existing_tags + created_tags    
+  end
+  
+  ### INSTANCE METHODS:
+  
   def ==(object)
     super || (object.is_a?(Tag) && name == object.name)
   end

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -1,8 +1,11 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe "acts_as_tagger" do
+  before(:each) do
+    [TaggableUser, TaggableModel, Tagging, Tag].each(&:destroy_all)
+  end
+  
   context "Tagger Method Generation" do
-
     before(:each) do
       @tagger = TaggableUser.new()
     end
@@ -78,9 +81,28 @@ 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.new
+        @user_y = TaggableUser.new
+        @taggable = TaggableModel.new(: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)
+      end
+      
+      it "should not delete other taggers tags" do
+        @user_y.tag(@taggable, :with => '', :on => :tags)
+        @taggable.all_tags_list_on(:tags).should include('ruby')
+      end
+      
+      it "should not delete original tags" do
+        @user_y.tag(@taggable, :with => '', :on => :tags)
+        @taggable.all_tags_list_on(:tags).should include('plugin')
+      end
+    end
   end
 
 end

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -38,6 +38,33 @@ describe Tag do
       }.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
+  end
 
   it "should require a name" do
     @tag.valid?

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -46,8 +46,8 @@ describe "Taggable" do
     @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

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -24,10 +24,10 @@ describe "Tagger" do
       @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)
+    @user.owned_tags.map(&:name).sort.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.tags_from(@user).sort.should == %w(ruby scheme)
+    @taggable.tags_from(@user2).sort.should == %w(java lisp python 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

metadata

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