acts-as-taggable-on 1.0.19 → 2.0.6

data/CHANGELOG

@@ -1,3 +1,6 @@
+== 2010-02-17
+* Converted the plugin to be compatible with Rails3
+
 == 2009-12-02
 
 * PostgreSQL is now supported (via morgoth)
@@ -12,10 +15,10 @@
 * Removed extraneous down migration cruft (azabaj)
 
 == 2008-06-09
- 
+
  * Added support for Single Table Inheritance
  * Adding gemspec and rails/init.rb for gemified plugin
- 
+
 == 2007-12-12
 
  * Added ability to use dynamic tag contexts

data/Gemfile

@@ -0,0 +1,10 @@
+source :gemcutter
+
+# Rails 3.0
+gem 'rails',        '3.0.0.beta3'
+gem 'rspec',        '2.0.0.beta.8'
+gem 'sqlite3-ruby', :require => 'sqlite3'
+gem 'mysql'
+gem 'pg'
+gem 'jeweler'
+gem 'rcov'

data/README.rdoc

@@ -15,33 +15,53 @@ was used.
 
 == Installation
 
-=== Plugin
+=== Rails 2.3.x
+
+Acts As Taggable On is tested to work in Rails 2.3.5. 
+
+==== Plugin
 
 Acts As Taggable On is available both as a gem and as a traditional plugin. For the
-traditional plugin you can install like so (Rails 2.1 or later):
+traditional plugin you can install like so:
 
   script/plugin install git://github.com/mbleigh/acts-as-taggable-on.git
-  
-=== 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 "acts-as-taggable-on", :source => "http://gemcutter.org"
+  config.gem "acts-as-taggable-on", :source => "http://gemcutter.org", :version => '2.0.0.rc1'
   
 After that, you can run "rake gems:install" to install the gem if you don't already have it.
 
-=== Post Installation (Rails)
+==== Post Installation
 
 1. script/generate acts_as_taggable_on_migration
 2. rake db:migrate
 
-=== Testing
+=== 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'
+
+==== Post Installation
+
+1. rails generate acts_as_taggable_on:migration
+2. rake db:migrate
+
+== Testing
 
 Acts As Taggable On uses RSpec for its test coverage. Inside the plugin
-directory, you can run the specs with:
+directory, you can run the specs for RoR 3.0.0 with:
+
+  rake spec
+
+If you want to test the plugin for Rails 2.3.x, use:
 
-rake spec
+  rake rails2.3:spec
 
 If you already have RSpec on your application, the specs will run while using:
 
@@ -51,35 +71,29 @@ rake spec:plugins
 == Usage
 
     class User < ActiveRecord::Base
-      acts_as_taggable_on :tags, :skills, :interests
+      # Alias for <tt>acts_as_taggable_on :tags</tt>:
+      acts_as_taggable
+      acts_as_taggable_on :skills, :interests
     end
 
     @user = User.new(:name => "Bobby")
     @user.tag_list = "awesome, slick, hefty"      # this should be familiar
     @user.skill_list = "joking, clowning, boxing" # but you can do it for any context!
-    @user.skill_list # => ["joking","clowning","boxing"] as TagList
+    @user.skill_list                              # => ["joking","clowning","boxing"] as TagList
     @user.save
 
     @user.tags # => [<Tag name:"awesome">,<Tag name:"slick">,<Tag name:"hefty">]
     @user.skills # => [<Tag name:"joking">,<Tag name:"clowning">,<Tag name:"boxing">]
 
-    # The old way
-    User.find_tagged_with("awesome", :on => :tags) # => [@user]
-    User.find_tagged_with("awesome", :on => :skills) # => []
-
-    # The better way (utilizes named_scope)
-    User.tagged_with("awesome", :on => :tags) # => [@user]
-    User.tagged_with("awesome", :on => :skills) # => []
-
     @frankie = User.create(:name => "Frankie", :skill_list => "joking, flying, eating")
     User.skill_counts # => [<Tag name="joking" count=2>,<Tag name="clowning" count=1>...]
     @frankie.skill_counts
 
 === Finding Tagged Objects
 
-Acts As Taggable On utilizes Rails 2.1's named_scope 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:
+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
@@ -89,6 +103,12 @@ also improves compatibility with the will_paginate gem:
     User.tagged_with("awesome").by_date
     User.tagged_with("awesome").by_date.paginate(:page => params[:page], :per_page => 20)
 
+    # Find a user with matching all tags, not just one
+    User.tagged_with(["awesome", "cool"], :match_all => :true)
+    
+    # Find a user with any of the tags:
+    User.tagged_with(["awesome", "cool"], :any => true)
+
 === Relationships
 
 You can find objects of the same type based on similar tags on certain contexts.
@@ -119,7 +139,7 @@ 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
 
@@ -154,7 +174,7 @@ Here is an example that generates a tag cloud.
 Helper:
 
   module PostsHelper
-    include TagsHelper
+    include ActsAsTaggableOn::TagsHelper
   end
 
 Controller:
@@ -182,11 +202,13 @@ CSS:
 
 * TomEric (i76) - Maintainer
 * Michael Bleigh - Original Author
+* Szymon Nowak - Rails 3.0 compatibility
+* Jelle Vandebeeck - Rails 3.0 compatibility
 * Brendan Lim - Related Objects
 * Pradeep Elankumaran - Taggers
 * Sinclair Bain - Patch King
 
-== Patch Contributors
+=== Patch Contributors
 
 * tristanzdunn - Related objects of other classes
 * azabaj - Fixed migrate down
@@ -196,4 +218,4 @@ CSS:
 * lawrencepit - cached tag work
 * sobrinho - fixed tag_cloud helper
 
-Copyright (c) 2007-2009 Michael Bleigh (http://mbleigh.com/) and Intridea Inc. (http://intridea.com/), released under the MIT license
+Copyright (c) 2007-2010 Michael Bleigh (http://mbleigh.com/) and Intridea Inc. (http://intridea.com/), released under the MIT license

data/Rakefile

@@ -1,4 +1,46 @@
-require 'spec/rake/spectask'
+begin
+  # Rspec 1.3.0
+  require 'spec/rake/spectask'
+
+  desc 'Default: run specs'
+  task :default => :spec
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList["spec/**/*_spec.rb"]
+  end
+
+  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
+end
 
 begin
   require 'jeweler'
@@ -13,17 +55,5 @@ begin
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
-
-desc 'Default: run specs'
-task :default => :spec
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = FileList["spec/**/*_spec.rb"]
-end
-
-Spec::Rake::SpecTask.new('rcov') do |t|
-  t.spec_files = FileList["spec/**/*_spec.rb"]
-  t.rcov = true
-  t.rcov_opts = ['--exclude', 'spec']
-end
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -1 +1 @@
-1.0.19
+2.0.6

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

@@ -1,7 +1,30 @@
-require 'acts_as_taggable_on/group_helper'
-require 'acts_as_taggable_on/acts_as_taggable_on'
-require 'acts_as_taggable_on/acts_as_tagger'
-require 'acts_as_taggable_on/tag'
-require 'acts_as_taggable_on/tag_list'
-require 'acts_as_taggable_on/tags_helper'
-require 'acts_as_taggable_on/tagging'
+require "active_record"
+require "action_view"
+
+$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/acts_as_taggable_on"
+require "acts_as_taggable_on/acts_as_taggable_on/core"
+require "acts_as_taggable_on/acts_as_taggable_on/collection"
+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/acts_as_tagger"
+require "acts_as_taggable_on/tag"
+require "acts_as_taggable_on/tag_list"
+require "acts_as_taggable_on/tags_helper"
+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, ActsAsTaggableOn::TagsHelper
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -0,0 +1,53 @@
+module ActsAsTaggableOn::Taggable
+  module Cache
+    def self.included(base)
+      # 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
+      
+      base.class_eval do
+        before_save :save_cached_tag_list        
+      end
+      
+      base.intialize_acts_as_taggable_on_cache
+    end
+    
+    module ClassMethods
+      def intialize_acts_as_taggable_on_cache      
+        tag_types.map(&:to_s).each do |tag_type|
+          class_eval %(
+            def self.caching_#{tag_type.singularize}_list?
+              caching_tag_list_on?("#{tag_type}")
+            end        
+          )
+        end        
+      end
+      
+      def acts_as_taggable_on(*args)
+        super(*args)
+        intialize_acts_as_taggable_on_cache
+      end
+      
+      def caching_tag_list_on?(context)
+        column_names.include?("cached_#{context.to_s.singularize}_list")
+      end
+    end
+    
+    module InstanceMethods      
+      def save_cached_tag_list
+        tag_types.map(&:to_s).each do |tag_type|
+          if self.class.send("caching_#{tag_type.singularize}_list?")
+            if tag_list_cache_set_on(tag_type)
+              list = tag_list_cache_on(tag_type.singularize).to_a.flatten.compact.join(', ')
+              self["cached_#{tag_type.singularize}_list"] = list
+            end
+          end
+        end
+        
+        true
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -0,0 +1,132 @@
+module ActsAsTaggableOn::Taggable
+  module Collection
+    def self.included(base)
+      base.send :include, ActsAsTaggableOn::Taggable::Collection::InstanceMethods
+      base.extend ActsAsTaggableOn::Taggable::Collection::ClassMethods
+      base.initialize_acts_as_taggable_on_collection
+    end
+    
+    module ClassMethods
+      def initialize_acts_as_taggable_on_collection
+        tag_types.map(&:to_s).each do |tag_type|
+          class_eval %(
+            def self.#{tag_type.singularize}_counts(options={})
+              tag_counts_on('#{tag_type}', options)
+            end
+
+            def #{tag_type.singularize}_counts(options = {})
+              tag_counts_on('#{tag_type}', options)
+            end
+
+            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        
+          )
+        end        
+      end
+      
+      def acts_as_taggable_on(*args)
+        super(*args)
+        initialize_acts_as_taggable_on_collection
+      end
+      
+      def tag_counts_on(context, options = {})
+        all_tag_counts(options.merge({:on => context.to_s}))
+      end
+      
+      ##
+      # Calculate the tag counts for all tags.
+      #
+      # @param [Hash] options Options:
+      #                       * :start_at   - Restrict the tags to those created after a certain time
+      #                       * :end_at     - Restrict the tags to those created before a certain time
+      #                       * :conditions - A piece of SQL conditions to add to the query
+      #                       * :limit      - The maximum number of tags to return
+      #                       * :order      - A piece of SQL to order by. Eg 'tags.count desc' or 'taggings.created_at desc'
+      #                       * :at_least   - Exclude tags with a frequency less than the given value
+      #                       * :at_most    - Exclude tags with a frequency greater than the given value
+      #                       * :on         - Scope the find to only include a certain context
+      def all_tag_counts(options = {})
+        options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
+
+        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]
+
+        conditions = [
+          taggable_conditions,
+          options[:conditions],
+          scope[:conditions],
+          start_at_conditions,
+          end_at_conditions
+        ].compact.reverse
+        
+        ## Generate joins:
+        tagging_join  = "LEFT OUTER JOIN #{ActsAsTaggableOn::Tagging.table_name} ON #{ActsAsTaggableOn::Tag.table_name}.id = #{ActsAsTaggableOn::Tagging.table_name}.tag_id"
+        tagging_join << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
+
+        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      
+
+        joins = [
+          tagging_join,
+          taggable_join,
+          scope[:joins]
+        ].compact
+
+        joins = joins.reverse if ActiveRecord::VERSION::MAJOR < 3
+
+
+        ## Generate scope:
+        scope = ActsAsTaggableOn::Tag.scoped(:select => "#{ActsAsTaggableOn::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 ')        
+
+        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("#{ActsAsTaggableOn::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(ActsAsTaggableOn::Tag)).having(having)
+        else
+          # Having is not available in 2.3.x:
+          group_by  = "#{grouped_column_names_for(ActsAsTaggableOn::Tag)} HAVING COUNT(*) > 0"
+          group_by << " AND #{having}" unless having.blank?
+          scope = scope.group(group_by)
+        end
+
+        scope
+      end
+    end
+    
+    module InstanceMethods
+      def tag_counts_on(context, options={})
+        self.class.tag_counts_on(context, options.merge(:id => id))
+      end
+    end
+  end
+end