acts-as-taggable-on 1.1.7 → 2.0.0

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,6 @@
+source :gemcutter
+
+# 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/README.rdoc

@@ -15,81 +15,85 @@ 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
+
+1. script/generate acts_as_taggable_on_migration
+2. rake db:migrate
+
 == 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. Because backwards compatibility is hard to maintain, their work is available
-in the feature/rails3_compatibility branch.
+and Jelle Vandebeeck.
 
-A Rails 3.0 compatible version of the gem is also available: 
+To use it, add it to your Gemfile:
   
-  gem install acts-as-taggable-on -v=2.0.0.pre1
+  gem 'acts-as-taggable-on', '2.0.0.rc1'
 
-=== Post Installation (Rails)
+=== Post Installation
 
-1. script/generate acts_as_taggable_on_migration
+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 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:
 
 rake spec:plugins
 
 
-== Usage
+= 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
+== 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
@@ -99,10 +103,13 @@ 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
+    # 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
+== 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 
@@ -121,7 +128,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!)
@@ -134,7 +141,7 @@ to allow for dynamic tag contexts (this could be user generated tag contexts!)
     @user.tag_counts_on(:customs)
     User.find_tagged_with("same", :on => :customs) # => [@user]
 
-=== Tag Ownership
+== Tag Ownership
 
 Tags can have owners:
 
@@ -151,7 +158,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
@@ -191,10 +198,12 @@ CSS:
   .css3 { font-size: 1.4em; }
   .css4 { font-size: 1.6em; }
 
-== Contributors
+= Contributors
 
 * 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
@@ -209,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.1.7
+2.0.0

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, 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 no cache columns exist
+      return unless 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,98 @@
+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
+
+        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
+
+        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?
+
+        Tag.select("#{Tag.table_name}.*, COUNT(*) AS count").joins(joins.join(" ")).where(conditions).group(group_by).limit(options[:limit]).order(options[:order])
+      end
+    end
+    
+    module InstanceMethods
+      def tag_counts_on(context, options={})
+        self.class.tag_counts_on(context, options.merge(:id => id))
+      end
+    end
+  end
+end