acts-as-taggable-on 1.0.6 → 1.0.7

data/README

@@ -35,17 +35,15 @@ GemPlugin
 Acts As Taggable On is also available as a gem plugin using Rails 2.1's gem dependencies.
 To install the gem, add this to your config/environment.rb:
   
-  config.gem "mbleigh-acts-as-taggable-on", :source => "http://gems.github.com", :lib => "acts-as-taggable-on"
+  config.gem "acts-as-taggable-on", :source => "http://gemcutter.org"
   
 After that, you can run "rake gems:install" to install the gem if you don't already have it.
-See http://ryandaigle.com/articles/2008/4/1/what-s-new-in-edge-rails-gem-dependencies for
-additional details about gem dependencies in Rails.
 
 ** NOTE **
 Some issues have been experienced with "rake gems:install". If that doesn't work to install the gem,
 try just installing it as a normal gem:
 
-  gem install mbleigh-acts-as-taggable-on --source http://gems.github.com
+  gem install acts-as-taggable-on --source http://gemcutter.org
 
 Post Installation (Rails)
 -------------------------

data/Rakefile

@@ -11,6 +11,7 @@ begin
     gemspec.authors = ["Michael Bleigh"]
     gemspec.files =  FileList["[A-Z]*", "{lib,spec,rails}/**/*"] - FileList["**/*.log"]
   end
+  Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end

data/VERSION

@@ -1 +1 @@
-1.0.6
+1.0.7

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -68,6 +68,10 @@ module ActiveRecord
               def top_#{tag_type}(limit = 10)
                 tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
               end
+              
+              def self.top_#{tag_type}(limit = 10)
+                tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
+              end
             RUBY
           end      
           
@@ -87,8 +91,8 @@ module ActiveRecord
               after_save :save_tags
               
               if respond_to?(:named_scope)
-                named_scope :tagged_with, lambda{ |tags, options|
-                  find_options_for_find_tagged_with(tags, options)
+                named_scope :tagged_with, lambda{ |*args|
+                  find_options_for_find_tagged_with(*args)
                 }
               end
             end
@@ -126,36 +130,55 @@ module ActiveRecord
         end           
         
         def find_options_for_find_tagged_with(tags, options = {})
-          tags = tags.is_a?(Array) ? TagList.new(tags.map(&:to_s)) : TagList.from(tags)
-
+          tags = TagList.from(tags)
+          
           return {} if tags.empty?
-
+          
+          joins = []
           conditions = []
-          conditions << sanitize_sql(options.delete(:conditions)) if options[:conditions]
           
-          unless (on = options.delete(:on)).nil?
-            conditions << sanitize_sql(["context = ?",on.to_s])
-          end
-
-          taggings_alias, tags_alias = "#{table_name}_taggings", "#{table_name}_tags"
+          context = options.delete(:on)
 
+          
           if options.delete(:exclude)
-            tags_conditions = tags.map { |t| sanitize_sql(["#{Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
-            conditions << sanitize_sql(["#{table_name}.id NOT IN (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name} LEFT OUTER JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id WHERE (#{tags_conditions}) AND #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})", tags])
-          else
-            conditions << tags.map { |t| sanitize_sql(["#{tags_alias}.name LIKE ?", t]) }.join(" OR ")
+            tags_conditions = "(" + tags.map { |t| sanitize_sql(["#{Tag.table_name}.name LIKE ?", t]) }.join(" OR ") + ")"
+            conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name} JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND #{tags_conditions} WHERE #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
+          
+          else          
+            tags.each do |tag|
+              safe_tag = tag.gsub(/[^a-zA-Z0-9]/, '')
+              prefix   = "#{safe_tag}_#{rand(1024)}"
+  
+              taggings_alias = "#{table_name}_taggings_#{prefix}"
+              tags_alias     = "#{table_name}_tags_#{prefix}"
+            
+              tagging_join  = "JOIN #{Tagging.table_name} #{taggings_alias}" +
+                              "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
+                              " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}"
+              tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+          
+              tag_join     = "JOIN #{Tag.table_name} #{tags_alias}" +
+                             "  ON #{tags_alias}.id = #{taggings_alias}.tag_id" +
+                             " AND " + sanitize_sql(["#{tags_alias}.name like ?", tag])
+          
+              joins << tagging_join
+              joins << tag_join
+            end            
+          end
+          
+          taggings_alias, tags_alias = "#{table_name}_taggings_group", "#{table_name}_tags_group"
 
-            if options.delete(:match_all)
-              group = "#{taggings_alias}.taggable_id HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
-            end
+          if options.delete(:match_all)
+            joins << "LEFT OUTER JOIN #{Tagging.table_name} #{taggings_alias}" +
+                     "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
+                     " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}"
+             
+            group = "#{table_name}.#{primary_key} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
           end
           
-          { :select => "DISTINCT #{table_name}.*",
-            :joins => "LEFT OUTER JOIN #{Tagging.table_name} #{taggings_alias} ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key} AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)} " +
-                      "LEFT OUTER JOIN #{Tag.table_name} #{tags_alias} ON #{tags_alias}.id = #{taggings_alias}.tag_id",
-            :conditions => conditions.join(" AND "),
-            :group      => group
-          }.update(options)
+          { :joins      => joins.join(" "),
+            :group      => group,
+            :conditions => conditions.join(" AND ") }.update(options)
         end    
         
         # Calculate the tag counts for all tags.
@@ -178,6 +201,7 @@ module ActiveRecord
 
           taggable_type = sanitize_sql(["#{Tagging.table_name}.taggable_type = ?", base_class.name])
           taggable_id = sanitize_sql(["#{Tagging.table_name}.taggable_id = ?", options.delete(:id)]) if options[:id]
+          options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
           
           conditions = [
             taggable_type,
@@ -192,7 +216,13 @@ module ActiveRecord
 
           joins = ["LEFT OUTER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"]
           joins << sanitize_sql(["AND #{Tagging.table_name}.context = ?",options.delete(:on).to_s]) unless options[:on].nil?
-          joins << "LEFT OUTER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"
+          
+          joins << " INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"
+          unless self.descends_from_active_record?
+            # Current model is STI descendant, so add type checking to the join condition
+            joins << " AND #{table_name}.#{self.inheritance_column} = '#{self.name}'"
+          end
+          
           joins << scope[:joins] if scope && scope[:joins]
 
           at_least  = sanitize_sql(['COUNT(*) >= ?', options.delete(:at_least)]) if options[:at_least]
@@ -204,7 +234,9 @@ module ActiveRecord
           { :select     => "#{Tag.table_name}.id, #{Tag.table_name}.name, COUNT(*) AS count", 
             :joins      => joins.join(" "),
             :conditions => conditions,
-            :group      => group_by
+            :group      => group_by,
+            :limit      => options[:limit],
+            :order      => options[:order]
           }
         end    
         

data/lib/acts_as_taggable_on/tag_list.rb

@@ -73,6 +73,8 @@ class TagList < Array
     #   tag_list = TagList.from("One , Two,  Three")
     #   tag_list # ["One", "Two", "Three"]
     def from(string)
+      string = string.join(", ") if string.respond_to?(:join)
+
       returning new do |tag_list|
         string = string.to_s.dup
         

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -20,6 +20,12 @@ describe TagList do
     @tag_list.include?("wicked").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
@@ -30,6 +36,11 @@ describe TagList do
     @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

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -117,6 +117,22 @@ describe "Taggable" do
     TaggableModel.tagged_with('rails', :on => :skills).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
+  
   describe "Single Table Inheritance" do
     before do
       [TaggableModel, Tag, Tagging, TaggableUser].each(&:delete_all)
@@ -143,5 +159,16 @@ describe "Taggable" do
       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)
+    end
   end
 end

data/spec/spec.opts

@@ -1,7 +1,3 @@
 --colour
---format
-specdoc
---loadby
-mtime
 --reverse
 --backtrace

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
 # require File.dirname(__FILE__) + '/../../../../spec/spec_helper'
 require 'rubygems'
-require 'active_support'
-require 'active_record'
+require 'activerecord'
 require 'spec'
 
 module Spec::Example::ExampleGroupMethods

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-taggable-on
 version: !ruby/object:Gem::Version 
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-14 00:00:00 -04:00
+date: 2009-11-12 00:00:00 -05:00
 default_executable: 
 dependencies: []