acts-as-taggable-on 2.4.0 → 2.4.1

data/lib/acts_as_taggable_on/acts_as_taggable_on/dirty.rb

@@ -34,4 +34,4 @@ module ActsAsTaggableOn::Taggable
       end
     end
   end
-end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -37,10 +37,14 @@ module ActsAsTaggableOn::Taggable
                                      #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = ? AND
                                      #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = ?), context.to_s, owner.id, owner.class.base_class.to_s])          
         end
+
         # when preserving tag order, return tags in created order
         # if we added the order to the association this would always apply
-        scope = scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id") if self.class.preserve_tag_order?
-        scope.all
+        if self.class.preserve_tag_order?
+          scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id")
+        else 
+          scope
+        end
       end
 
       def cached_owned_tag_list_on(context)
@@ -52,7 +56,6 @@ module ActsAsTaggableOn::Taggable
         add_custom_context(context)
 
         cache = cached_owned_tag_list_on(context)
-        cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
         
         cache[owner] ||= ActsAsTaggableOn::TagList.new(*owner_tags_on(owner, context).map(&:name))
       end
@@ -61,7 +64,6 @@ module ActsAsTaggableOn::Taggable
         add_custom_context(context)
         
         cache = cached_owned_tag_list_on(context)
-        cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
 
         cache[owner] = ActsAsTaggableOn::TagList.from(new_list)
       end
@@ -86,13 +88,20 @@ module ActsAsTaggableOn::Taggable
                
             # Tag maintenance based on whether preserving the created order of tags
             if self.class.preserve_tag_order?
-              # First off order the array of tag objects to match the tag list
-              # rather than existing tags followed by new tags
-              tags = tag_list.uniq.map{|s| tags.detect{|t| t.name.downcase == s.downcase}}
-              # To preserve tags in the order in which they were added
-              # delete all owned tags and create new tags if the content or order has changed
-              old_tags = (tags == owned_tags ? [] : owned_tags)
-              new_tags = (tags == owned_tags ? [] : tags)
+              old_tags, new_tags = owned_tags - tags, tags - owned_tags
+
+              shared_tags = owned_tags & tags
+
+              if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
+                index = shared_tags.each_with_index { |_, i| break i unless shared_tags[i] == tags[i] }
+
+                # Update arrays of tag objects
+                old_tags |= owned_tags.from(index)
+                new_tags |= owned_tags.from(index) & shared_tags
+
+                # Order the array of tag objects to match the tag list
+                new_tags = tags.map { |t| new_tags.find { |n| n.name.downcase == t.name.downcase } }.compact
+              end
             else
               # Delete discarded tags and create new tags
               old_tags = owned_tags - tags
@@ -104,7 +113,7 @@ module ActsAsTaggableOn::Taggable
             if old_tags.present?
               old_taggings = ActsAsTaggableOn::Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
                                                              :tagger_type => owner.class.base_class.to_s, :tagger_id => owner.id,
-                                                             :tag_id => old_tags, :context => context).all
+                                                             :tag_id => old_tags, :context => context)
             end
           
             # Destroy old taggings:

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -44,31 +44,40 @@ module ActsAsTaggableOn::Taggable
       def matching_contexts_for(search_context, result_context, klass, options = {})
         tags_to_find = tags_on(search_context).collect { |t| t.name }
 
-        exclude_self = "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
-
-        group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
-
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count",
-                       :from       => "#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context],
-                       :group      => group_columns,
-                       :order      => "count DESC" }.update(options))
+        klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count") \
+             .from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}") \
+             .where(["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context]) \
+             .group(group_columns(klass)) \
+             .order("count DESC")
       end
 
       def related_tags_for(context, klass, options = {})
-				tags_to_ignore = Array.wrap(options.delete(:ignore)) || []
-				tags_to_ignore.map! { |t| t.to_s }
+				tags_to_ignore = Array.wrap(options.delete(:ignore)).map(&:to_s) || []
         tags_to_find = tags_on(context).collect { |t| t.name }.reject { |t| tags_to_ignore.include? t }
 
-        exclude_self = "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
+        klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count") \
+             .from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}") \
+             .where(["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?)", tags_to_find]) \
+             .group(group_columns(klass)) \
+             .order("count DESC")
+      end
 
-        group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
+      private
+      
+      def exclude_self(klass, id)
+        if [self.class.base_class, self.class].include? klass
+          "#{klass.table_name}.#{klass.primary_key} != #{id} AND" 
+        else
+          nil
+        end
+      end
 
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count",
-                       :from       => "#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?)", tags_to_find],
-                       :group      => group_columns,
-                       :order      => "count DESC" }.update(options))
+      def group_columns(klass)
+        if ActsAsTaggableOn::Tag.using_postgresql? 
+          grouped_column_names_for(klass)
+        else
+          "#{klass.table_name}.#{klass.primary_key}"
+        end
       end
     end
   end

data/lib/acts_as_taggable_on/tag.rb

@@ -2,7 +2,7 @@ module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
     include ActsAsTaggableOn::Utils
 
-    attr_accessible :name
+    attr_accessible :name if defined?(ActiveModel::MassAssignmentSecurity)
 
     ### ASSOCIATIONS:
 
@@ -60,14 +60,14 @@ module ActsAsTaggableOn
 
       return [] if list.empty?
 
-      existing_tags = Tag.named_any(list).all
-      new_tag_names = list.reject do |name|
-        name = comparable_name(name)
-        existing_tags.any? { |tag| comparable_name(tag.name) == name }
-      end
-      created_tags  = new_tag_names.map { |name| Tag.create(:name => name) }
+      existing_tags = Tag.named_any(list)
+
+      list.map do |tag_name|
+        comparable_tag_name = comparable_name(tag_name)
+        existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
 
-      existing_tags + created_tags
+        existing_tag || Tag.create(:name => tag_name)
+      end
     end
 
     ### INSTANCE METHODS:

data/lib/acts_as_taggable_on/taggable.rb

@@ -80,7 +80,7 @@ module ActsAsTaggableOn
           self.preserve_tag_order = preserve_tag_order
         
           class_eval do
-            has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging"
+            has_many :taggings, :as => :taggable, :dependent => :destroy, :class_name => "ActsAsTaggableOn::Tagging"
             has_many :base_tags, :through => :taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
 
             def self.taggable?
@@ -88,14 +88,17 @@ module ActsAsTaggableOn
             end
 
             include ActsAsTaggableOn::Utils
-            include ActsAsTaggableOn::Taggable::Core
-            include ActsAsTaggableOn::Taggable::Collection
-            include ActsAsTaggableOn::Taggable::Cache
-            include ActsAsTaggableOn::Taggable::Ownership
-            include ActsAsTaggableOn::Taggable::Related
-            include ActsAsTaggableOn::Taggable::Dirty
           end
         end
+
+        # each of these add context-specific methods and must be
+        # called on each call of taggable_on
+        include ActsAsTaggableOn::Taggable::Core
+        include ActsAsTaggableOn::Taggable::Collection
+        include ActsAsTaggableOn::Taggable::Cache
+        include ActsAsTaggableOn::Taggable::Ownership
+        include ActsAsTaggableOn::Taggable::Related
+        include ActsAsTaggableOn::Taggable::Dirty
       end
 
   end

data/lib/acts_as_taggable_on/tagger.rb

@@ -15,9 +15,18 @@ module ActsAsTaggableOn
       #   end
       def acts_as_tagger(opts={})
         class_eval do
-          has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy,
-                                               :include => :tag, :class_name => "ActsAsTaggableOn::Tagging")
-          has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true, :class_name => "ActsAsTaggableOn::Tag"
+          has_many_with_compatibility :owned_taggings, 
+            opts.merge(
+              :as => :tagger, 
+              :dependent => :destroy,
+              :class_name => "ActsAsTaggableOn::Tagging"
+            )
+
+          has_many_with_compatibility :owned_tags, 
+                                      :through => :owned_taggings, 
+                                      :source => :tag, 
+                                      :class_name => "ActsAsTaggableOn::Tag", 
+                                      :uniq => true
         end
 
         include ActsAsTaggableOn::Tagger::InstanceMethods

data/lib/acts_as_taggable_on/tagging.rb

@@ -8,7 +8,7 @@ module ActsAsTaggableOn
                     :taggable_id,
                     :tagger,
                     :tagger_type,
-                    :tagger_id
+                    :tagger_id if defined?(ActiveModel::MassAssignmentSecurity)
 
     belongs_to :tag, :class_name => 'ActsAsTaggableOn::Tag'
     belongs_to :taggable, :polymorphic => true
@@ -31,4 +31,4 @@ module ActsAsTaggableOn
       end
     end
   end
-end
+end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -2,8 +2,6 @@ module ActsAsTaggableOn
   module TagsHelper
     # See the README for an example using tag_cloud.
     def tag_cloud(tags, classes)
-      tags = tags.all if tags.respond_to?(:all)
-
       return [] if tags.empty?
 
       max_count = tags.sort_by(&:count).last.count.to_f

data/lib/{acts-as-taggable-on → acts_as_taggable_on}/version.rb

@@ -1,4 +1,4 @@
 module ActsAsTaggableOn
-  VERSION = '2.4.0'
+  VERSION = '2.4.1'
 end
 

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../spec_helper', __FILE__)
+require 'spec_helper'
 
 describe "Acts As Taggable On" do
   before(:each) do
@@ -77,23 +77,6 @@ describe "Acts As Taggable On" do
     end
   end
 
-  describe "Single Table Inheritance" do
-    before do
-      @taggable = TaggableModel.new(:name => "taggable")
-      @inherited_same = InheritingTaggableModel.new(:name => "inherited same")
-      @inherited_different = AlteredInheritingTaggableModel.new(:name => "inherited different")
-    end
-
-    it "should pass on tag contexts to STI-inherited models" do
-      @inherited_same.should respond_to(:tag_list, :skill_list, :language_list)
-      @inherited_different.should respond_to(:tag_list, :skill_list, :language_list)
-    end
-
-    it "should have tag contexts added in altered STI models" do
-      @inherited_different.should respond_to(:part_list)
-    end
-  end
-
   describe "Reloading" do
     it "should save a model instantiated by Model.find" do
       taggable = TaggableModel.create!(:name => "Taggable")
@@ -102,161 +85,6 @@ describe "Acts As Taggable On" do
     end
   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 "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
-
-    context "Inherited Models" do
-      before do
-        @taggable1 = InheritingTaggableModel.create!(:name => "InheritingTaggable 1")
-        @taggable2 = InheritingTaggableModel.create!(:name => "InheritingTaggable 2")
-        @taggable3 = InheritingTaggableModel.create!(:name => "InheritingTaggable 3")
-        @taggable4 = TaggableModel.create!(:name => "Taggable 4")
-
-        @taggable1.tag_list = "one, two"
-        @taggable1.save
-
-        @taggable2.tag_list = "three, four"
-        @taggable2.save
-
-        @taggable3.tag_list = "one, four"
-        @taggable3.save
-
-        @taggable4.tag_list = "one, two, three, four"
-        @taggable4.save
-      end
-
-      it "should find related objects based on tag names on context" do
-        @taggable1.find_related_tags.should include(@taggable3)
-        @taggable1.find_related_tags.should_not include(@taggable2)
-        @taggable1.find_related_tags.should_not include(@taggable4)
-
-        @taggable1.find_related_tags_for(TaggableModel).should include(@taggable3)
-        @taggable1.find_related_tags_for(TaggableModel).should_not include(@taggable2)
-        @taggable1.find_related_tags_for(TaggableModel).should include(@taggable4)
-      end
-
-      it "should not include the object itself in the list of related objects" do
-        @taggable1.find_related_tags.should_not include(@taggable1)
-        @taggable1.find_related_tags_for(InheritingTaggableModel).should_not include(@taggable1)
-        @taggable1.find_related_tags_for(TaggableModel).should_not include(@taggable1)
-      end
-    end
-
-  end
-
   describe "Matching Contexts" do
     it "should find objects with tags of matching contexts" do
       taggable1 = TaggableModel.create!(:name => "Taggable 1")
@@ -309,49 +137,6 @@ describe "Acts As Taggable On" do
       taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(taggable1)
     end
 
-    context "Inherited Models" do
-      before do
-        @taggable1 = InheritingTaggableModel.create!(:name => "InheritingTaggable 1")
-        @taggable2 = InheritingTaggableModel.create!(:name => "InheritingTaggable 2")
-        @taggable3 = InheritingTaggableModel.create!(:name => "InheritingTaggable 3")
-        @taggable4 = InheritingTaggableModel.create!(:name => "InheritingTaggable 4")
-        @taggable5 = TaggableModel.create!(:name => "Taggable 5")
-
-        @taggable1.offering_list = "one, two"
-        @taggable1.need_list = "one, two"
-        @taggable1.save!
-
-        @taggable2.need_list = "one, two"
-        @taggable2.save!
-
-        @taggable3.offering_list = "one, two"
-        @taggable3.save!
-
-        @taggable4.tag_list = "one, two, three, four"
-        @taggable4.save!
-
-        @taggable5.need_list = "one, two"
-        @taggable5.save!
-      end
-
-      it "should find objects with tags of matching contexts" do
-        @taggable1.find_matching_contexts(:offerings, :needs).should include(@taggable2)
-        @taggable1.find_matching_contexts(:offerings, :needs).should_not include(@taggable3)
-        @taggable1.find_matching_contexts(:offerings, :needs).should_not include(@taggable4)
-        @taggable1.find_matching_contexts(:offerings, :needs).should_not include(@taggable5)
-
-        @taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should include(@taggable2)
-        @taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(@taggable3)
-        @taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(@taggable4)
-        @taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should include(@taggable5)
-      end
-
-      it "should not include the object itself in the list of related objects with tags of matching contexts" do
-        @taggable1.find_matching_contexts(:offerings, :needs).should_not include(@taggable1)
-        @taggable1.find_matching_contexts_for(InheritingTaggableModel, :offerings, :needs).should_not include(@taggable1)
-        @taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs).should_not include(@taggable1)
-      end
-    end
   end
 
   describe 'Tagging Contexts' do