acts-as-taggable-on 2.0.0 → 2.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.log
+*.sqlite3
+/pkg/*
+.bundle
+.rvmrc
+Gemfile.lock
+spec/database.yml

data/.travis.yml

@@ -0,0 +1,10 @@
+script: "cp spec/database.yml.sample spec/database.yml && bundle install && bundle exec rake"
+rvm:
+  - 1.8.7
+  - ree
+  - 1.9.2
+  - rbx
+env:
+  - DB=sqlite3
+  - DB=mysql
+  - DB=postgresql

data/Gemfile

@@ -1,6 +1,3 @@
-source :gemcutter
+source 'http://rubygems.org'
+gemspec
 
-# Rails 3.0
-gem 'rails',        '3.0.0.beta'
-gem 'rspec',        '2.0.0.beta.1'
-gem 'sqlite3-ruby', '1.2.5',       :require => 'sqlite3'

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/README.rdoc

@@ -38,21 +38,21 @@ After that, you can run "rake gems:install" to install the gem if you don't alre
 1. script/generate acts_as_taggable_on_migration
 2. rake db:migrate
 
-== Rails 3.0
+=== Rails 3.0
 
 Acts As Taggable On is now useable in Rails 3.0, thanks to the excellent work of Szymon Nowak
 and Jelle Vandebeeck.
 
 To use it, add it to your Gemfile:
   
-  gem 'acts-as-taggable-on', '2.0.0.rc1'
+  gem 'acts-as-taggable-on'
 
-=== Post Installation
+==== Post Installation
 
 1. rails generate acts_as_taggable_on:migration
 2. rake db:migrate
 
-= Testing
+== Testing
 
 Acts As Taggable On uses RSpec for its test coverage. Inside the plugin
 directory, you can run the specs for RoR 3.0.0 with:
@@ -68,7 +68,7 @@ If you already have RSpec on your application, the specs will run while using:
 rake spec:plugins
 
 
-= Usage
+== Usage
 
     class User < ActiveRecord::Base
       # Alias for <tt>acts_as_taggable_on :tags</tt>:
@@ -89,14 +89,14 @@ rake spec:plugins
     User.skill_counts # => [<Tag name="joking" count=2>,<Tag name="clowning" count=1>...]
     @frankie.skill_counts
 
-== Finding Tagged Objects
+=== Finding Tagged Objects
 
 Acts As Taggable On utilizes named_scopes to create an association for tags.
 This way you can mix and match to filter down your results, and it also improves
 compatibility with the will_paginate gem:
 
     class User < ActiveRecord::Base
-      acts_as_taggable_on :tags
+      acts_as_taggable_on :tags, :skills
       named_scope :by_join_date, :order => "created_at DESC"
     end
 
@@ -108,8 +108,11 @@ compatibility with the will_paginate gem:
     
     # Find a user with any of the tags:
     User.tagged_with(["awesome", "cool"], :any => true)
-
-== Relationships
+    
+    # Find a user with any of tags based on context:
+    User.tagged_with(['awesome, cool'], :on => :tags, :any => true).tagged_with(['smart', 'shy'], :on => :skills, :any => true)
+    
+=== Relationships
 
 You can find objects of the same type based on similar tags on certain contexts.
 Also, objects will be returned in descending order based on the total number of 
@@ -128,7 +131,7 @@ matched tags.
     @bobby.find_related_skills # => [<User name="Tom">] 
     @frankie.find_related_skills # => [<User name="Tom">] 
 
-== Dynamic Tag Contexts
+=== Dynamic Tag Contexts
 
 In addition to the generated tag contexts in the definition, it is also possible
 to allow for dynamic tag contexts (this could be user generated tag contexts!)
@@ -139,9 +142,9 @@ to allow for dynamic tag contexts (this could be user generated tag contexts!)
     @user.save
     @user.tags_on(:customs) # => [<Tag name='same'>,...]
     @user.tag_counts_on(:customs)
-    User.find_tagged_with("same", :on => :customs) # => [@user]
+    User.tagged_with("same", :on => :customs) # => [@user]
 
-== Tag Ownership
+=== Tag Ownership
 
 Tags can have owners:
 
@@ -158,7 +161,7 @@ Tags can have owners:
     @some_user.owned_tags
     @some_photo.locations_from(@some_user)
     
-== Tag cloud calculations
+=== Tag cloud calculations
 
 To construct tag clouds, the frequency of each tag needs to be calculated.
 Because we specified +acts_as_taggable_on+ on the <tt>User</tt> class, we can
@@ -174,7 +177,7 @@ Here is an example that generates a tag cloud.
 Helper:
 
   module PostsHelper
-    include TagsHelper
+    include ActsAsTaggableOn::TagsHelper
   end
 
 Controller:
@@ -198,7 +201,7 @@ CSS:
   .css3 { font-size: 1.4em; }
   .css4 { font-size: 1.6em; }
 
-= Contributors
+== Contributors
 
 * TomEric (i76) - Maintainer
 * Michael Bleigh - Original Author
@@ -208,7 +211,7 @@ CSS:
 * Pradeep Elankumaran - Taggers
 * Sinclair Bain - Patch King
 
-== Patch Contributors
+=== Patch Contributors
 
 * tristanzdunn - Related objects of other classes
 * azabaj - Fixed migrate down

data/Rakefile

@@ -1,59 +1,13 @@
-begin
-  # Rspec 1.3.0
-  require 'spec/rake/spectask'
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development
 
-  desc 'Default: run specs'
-  task :default => :spec
-  Spec::Rake::SpecTask.new do |t|
-    t.spec_files = FileList["spec/**/*_spec.rb"]
-  end
+desc 'Default: run specs'
+task :default => :spec  
 
-  Spec::Rake::SpecTask.new('rcov') do |t|
-    t.spec_files = FileList["spec/**/*_spec.rb"]
-    t.rcov = true
-    t.rcov_opts = ['--exclude', 'spec']
-  end
-  
-rescue LoadError
-  # Rspec 2.0
-  require 'rspec/core/rake_task'
-
-  desc 'Default: run specs'
-  task :default => :spec  
-  Rspec::Core::RakeTask.new do |t|
-    t.pattern = "spec/**/*_spec.rb"
-  end
-  
-  Rspec::Core::RakeTask.new('rcov') do |t|
-    t.pattern = "spec/**/*_spec.rb"
-    t.rcov = true
-    t.rcov_opts = ['--exclude', 'spec']
-  end
-
-rescue LoadError
-  puts "Rspec not available. Install it with: gem install rspec"  
-end
-
-namespace 'rails2.3' do
-  task :spec do
-    gemfile = File.join(File.dirname(__FILE__), 'lib', 'acts_as_taggable_on', 'compatibility', 'Gemfile')
-    ENV['BUNDLE_GEMFILE'] = gemfile
-    Rake::Task['spec'].invoke    
-  end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
 end
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "acts-as-taggable-on"
-    gemspec.summary = "ActsAsTaggableOn is a tagging plugin for Rails that provides multiple tagging contexts on a single model."
-    gemspec.description = "With ActsAsTaggableOn, you could tag a single model on several contexts, such as skills, interests, and awards. It also provides other advanced functionality."
-    gemspec.email = "michael@intridea.com"
-    gemspec.homepage = "http://github.com/mbleigh/acts-as-taggable-on"
-    gemspec.authors = ["Michael Bleigh"]
-    gemspec.files =  FileList["[A-Z]*", "{generators,lib,spec,rails}/**/*"] - FileList["**/*.log"]
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: gem install jeweler"
-end
+Bundler::GemHelper.install_tasks

data/VERSION

@@ -1 +1 @@
-2.0.0
+2.0.6

data/acts-as-taggable-on.gemspec

@@ -0,0 +1,27 @@
+$:.push File.dirname(__FILE__) + '/lib'
+require 'acts-as-taggable-on/version'
+
+Gem::Specification.new do |gem|
+  gem.name = %q{acts-as-taggable-on}
+  gem.authors = ["Michael Bleigh"]
+  gem.date = %q{2010-05-19}
+  gem.description = %q{With ActsAsTaggableOn, you can tag a single model on several contexts, such as skills, interests, and awards. It also provides other advanced functionality.}
+  gem.summary = "Advanced tagging for Rails."
+  gem.email = %q{michael@intridea.com}
+  gem.homepage      = ''
+
+  gem.add_runtime_dependency 'rails'
+  gem.add_development_dependency 'rspec', '~> 2.5'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'mysql2', '< 0.3'
+  gem.add_development_dependency 'pg'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-rspec'
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "acts-as-taggable-on"
+  gem.require_paths = ['lib']
+  gem.version       = ActsAsTaggableOn::VERSION
+end

data/lib/acts-as-taggable-on/version.rb

@@ -0,0 +1,4 @@
+module ActsAsTaggableOn
+  VERSION = '2.1.0'
+end
+

data/lib/acts-as-taggable-on.rb

@@ -1,9 +1,13 @@
 require "active_record"
+require "active_record/version"
 require "action_view"
+RAILS_3 = ::ActiveRecord::VERSION::MAJOR >= 3
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
-require "acts_as_taggable_on/compatibility/active_record_backports" if ActiveRecord::VERSION::MAJOR < 3
+require "acts_as_taggable_on/compatibility/active_record_backports" unless RAILS_3
+
+require "acts_as_taggable_on/utils"
 
 require "acts_as_taggable_on/acts_as_taggable_on"
 require "acts_as_taggable_on/acts_as_taggable_on/core"
@@ -12,6 +16,7 @@ require "acts_as_taggable_on/acts_as_taggable_on/cache"
 require "acts_as_taggable_on/acts_as_taggable_on/ownership"
 require "acts_as_taggable_on/acts_as_taggable_on/related"
 
+#require "acts_as_taggable_on/utils"
 require "acts_as_taggable_on/acts_as_tagger"
 require "acts_as_taggable_on/tag"
 require "acts_as_taggable_on/tag_list"
@@ -20,11 +25,12 @@ require "acts_as_taggable_on/tagging"
 
 $LOAD_PATH.shift
 
+
 if defined?(ActiveRecord::Base)
   ActiveRecord::Base.extend ActsAsTaggableOn::Taggable
   ActiveRecord::Base.send :include, ActsAsTaggableOn::Tagger
 end
 
 if defined?(ActionView::Base)
-  ActionView::Base.send :include, TagsHelper
+  ActionView::Base.send :include, ActsAsTaggableOn::TagsHelper
 end

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -1,8 +1,8 @@
 module ActsAsTaggableOn::Taggable
   module Cache
     def self.included(base)
-      # Skip adding caching capabilities if no cache columns exist
-      return unless base.tag_types.any? { |context| base.column_names.include?("cached_#{context.to_s.singularize}_list") }
+      # Skip adding caching capabilities if table not exists or no cache columns exist
+      return unless base.table_exists? && base.tag_types.any? { |context| base.column_names.include?("cached_#{context.to_s.singularize}_list") }
 
       base.send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
       base.extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
@@ -11,11 +11,11 @@ module ActsAsTaggableOn::Taggable
         before_save :save_cached_tag_list        
       end
       
-      base.intialize_acts_as_taggable_on_cache
+      base.initialize_acts_as_taggable_on_cache
     end
     
     module ClassMethods
-      def intialize_acts_as_taggable_on_cache      
+      def initialize_acts_as_taggable_on_cache      
         tag_types.map(&:to_s).each do |tag_type|
           class_eval %(
             def self.caching_#{tag_type.singularize}_list?
@@ -27,7 +27,7 @@ module ActsAsTaggableOn::Taggable
       
       def acts_as_taggable_on(*args)
         super(*args)
-        intialize_acts_as_taggable_on_cache
+        initialize_acts_as_taggable_on_cache
       end
       
       def caching_tag_list_on?(context)
@@ -50,4 +50,4 @@ module ActsAsTaggableOn::Taggable
       end
     end
   end
-end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -53,39 +53,80 @@ 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]
-
-        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,
-          taggable_id,
-          options[:conditions],
-          start_at,
-          end_at
-        ]
-
-        conditions = conditions.compact.join(' AND ')
-
-        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"
-
-        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
+        scope = if ActiveRecord::VERSION::MAJOR >= 3
+                  {}
+                else
+                  scope(:find) || {}           
+                end
+
+        ## Generate conditions:
+        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]     
+
+        start_at_conditions = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+        end_at_conditions   = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
+        
+        taggable_conditions  = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.taggable_type = ?", base_class.name])
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = ?", options.delete(:id)])  if options[:id]
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
+        
+        tagging_conditions = [
+          taggable_conditions,
+          scope[:conditions],
+          start_at_conditions,
+          end_at_conditions
+        ].compact.reverse
+        
+        tag_conditions = [
+          options[:conditions]        
+        ].compact.reverse
+        
+        ## Generate joins:
+        taggable_join = "INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{ActsAsTaggableOn::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      
+
+        tagging_joins = [
+          taggable_join,
+          scope[:joins]
+        ].compact
+
+        tag_joins = [
+        ].compact
+
+        [tagging_joins, tag_joins].each(&:reverse!) if ActiveRecord::VERSION::MAJOR < 3
 
-        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?
+        ## Generate scope:
+        tagging_scope = ActsAsTaggableOn::Tagging.select("#{ActsAsTaggableOn::Tagging.table_name}.tag_id, COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) AS tags_count")
+        tag_scope = ActsAsTaggableOn::Tag.select("#{ActsAsTaggableOn::Tag.table_name}.*, #{ActsAsTaggableOn::Tagging.table_name}.tags_count AS count").order(options[:order]).limit(options[:limit])   
+
+        # Joins and conditions
+        tagging_joins.each      { |join|      tagging_scope = tagging_scope.joins(join)      }        
+        tagging_conditions.each { |condition| tagging_scope = tagging_scope.where(condition) }
+
+        tag_joins.each          { |join|      tag_scope     = tag_scope.joins(join)          }
+        tag_conditions.each     { |condition| tag_scope     = tag_scope.where(condition)     }
+
+        # GROUP BY and HAVING clauses:
+        at_least  = sanitize_sql(['tags_count >= ?', options.delete(:at_least)]) if options[:at_least]
+        at_most   = sanitize_sql(['tags_count <= ?', options.delete(:at_most)]) if options[:at_most]
+        having    = ["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) > 0", at_least, at_most].compact.join(' AND ')    
+
+        group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
+
+        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}"
+          tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{select(scoped_select).to_sql})").
+                                        group(group_columns).
+                                        having(having)
+        else
+          # Having is not available in 2.3.x:
+          group_by  = "#{group_columns} HAVING COUNT(*) > 0"
+          group_by << " AND #{having}" unless having.blank?
+          tagging_scope = tagging_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])
+        tag_scope = tag_scope.joins("JOIN (#{tagging_scope.to_sql}) AS taggings ON taggings.tag_id = tags.id")
+        tag_scope
       end
     end