acts-as-taggable-on 2.0.0 → 2.0.1

data/VERSION

@@ -1 +1 @@
-2.0.0
+2.0.1

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -53,39 +53,71 @@ module ActsAsTaggableOn::Taggable
       def all_tag_counts(options = {})
         options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
 
-        start_at = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
-        end_at = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
+        scope = if ActiveRecord::VERSION::MAJOR >= 3
+                  {}
+                else
+                  scope(:find) || {}           
+                end
 
-        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]
+        ## Generate conditions:
+        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]     
+          
+        start_at_conditions = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+        end_at_conditions   = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
+
+        taggable_conditions  = sanitize_sql(["#{Tagging.table_name}.taggable_type = ?", base_class.name])
+        taggable_conditions << sanitize_sql([" AND #{Tagging.table_name}.taggable_id = ?", options.delete(:id)]) if options[:id]
 
         conditions = [
-          taggable_type,
-          taggable_id,
+          taggable_conditions,
           options[:conditions],
-          start_at,
-          end_at
-        ]
+          scope[:conditions],
+          start_at_conditions,
+          end_at_conditions
+        ].compact
+        
+        ## Generate joins:
+        tagging_join  = "LEFT OUTER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"
+        tagging_join << sanitize_sql([" AND #{Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
 
-        conditions = conditions.compact.join(' AND ')
+        taggable_join = "INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"
+        taggable_join << " AND #{table_name}.#{inheritance_column} = '#{name}'" unless descends_from_active_record? # Current model is STI descendant, so add type checking to the join condition      
 
-        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 << " INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"
+        joins = [
+          tagging_join,
+          taggable_join,
+          scope[:joins]
+        ].compact
 
-        unless descends_from_active_record?
-          # Current model is STI descendant, so add type checking to the join condition
-          joins << " AND #{table_name}.#{inheritance_column} = '#{name}'"
-        end
 
+        ## Generate scope:
+        scope = Tag.scoped(:select => "#{Tag.table_name}.*, COUNT(*) AS count").order(options[:order]).limit(options[:limit])   
+        
+        # Joins and conditions
+        joins.each      { |join|      scope = scope.joins(join)      }
+        conditions.each { |condition| scope = scope.where(condition) }
+        
+        # GROUP BY and HAVING clauses:
         at_least  = sanitize_sql(['COUNT(*) >= ?', options.delete(:at_least)]) if options[:at_least]
         at_most   = sanitize_sql(['COUNT(*) <= ?', options.delete(:at_most)]) if options[:at_most]
-        having    = [at_least, at_most].compact.join(' AND ')
-        group_by  = "#{grouped_column_names_for(Tag)} HAVING COUNT(*) > 0"
-        group_by << " AND #{having}" unless having.blank?
+        having    = [at_least, at_most].compact.join(' AND ')        
+
+        if ActiveRecord::VERSION::MAJOR >= 3
+          # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
+          scoped_select = "#{table_name}.#{primary_key}"
+          scope = scope.where("#{Tagging.table_name}.taggable_id IN(#{select(scoped_select).to_sql})")
+          
+          # We have having() in RoR 3.0 so use it:
+          having = having.blank? ? "COUNT(*) > 0" : "COUNT(*) > 0 AND #{having}"
+          scope = scope.group(grouped_column_names_for(Tag)).having(having)
+        else
+          # Having is not available in 2.3.x:
+          group_by  = "#{grouped_column_names_for(Tag)} HAVING COUNT(*) > 0"
+          group_by << " AND #{having}" unless having.blank?
+          scope = scope.group(group_by)
+        end
 
-        Tag.select("#{Tag.table_name}.*, COUNT(*) AS count").joins(joins.join(" ")).where(conditions).group(group_by).limit(options[:limit]).order(options[:order])
+        scope
       end
     end
     

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -144,6 +144,21 @@ describe "Taggable" do
     TaggableModel.tagged_with("ruby").all_tag_counts.first.count.should == 3 # ruby
   end
 
+  it 'should only return tag counts for the available scope' 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, java")
+ 
+    TaggableModel.tagged_with('rails').all_tag_counts.should have(3).items
+    TaggableModel.tagged_with('rails').all_tag_counts.any? { |tag| tag.name == 'java' }.should be_false
+    
+    # Test specific join syntaxes:
+    frank.untaggable_models.create!
+    TaggableModel.tagged_with('rails').scoped(:joins => :untaggable_models).all_tag_counts.should have(2).items
+    TaggableModel.tagged_with('rails').scoped(:joins => { :untaggable_models => :taggable_model }).all_tag_counts.should have(2).items
+    TaggableModel.tagged_with('rails').scoped(:joins => [:untaggable_models]).all_tag_counts.should have(2).items
+  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")

data/spec/models.rb

@@ -27,4 +27,5 @@ class TaggableUser < ActiveRecord::Base
 end
 
 class UntaggableModel < ActiveRecord::Base
+  belongs_to :taggable_model
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 2
   - 0
-  - 0
-  version: 2.0.0
+  - 1
+  version: 2.0.1
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-28 00:00:00 +01:00
+date: 2010-03-30 00:00:00 +02:00
 default_executable: 
 dependencies: []