acts-as-taggable-on 1.1.9 → 2.0.0.pre1

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,8 @@
+source :gemcutter
+
+gem 'rails', '3.0.0.beta'
+
+group :test do
+  gem 'rspec', '2.0.0.beta.1'
+  gem 'sqlite3-ruby', :require => 'sqlite3'
+end

data/README.rdoc

@@ -31,16 +31,6 @@ To install the gem, add this to your config/environment.rb:
   
 After that, you can run "rake gems:install" to install the gem if you don't already have it.
 
-== 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.
-
-A Rails 3.0 compatible version of the gem is also available: 
-  
-  gem install acts-as-taggable-on -v=2.0.0.pre1
-
 === Post Installation (Rails)
 
 1. script/generate acts_as_taggable_on_migration

data/Rakefile

@@ -1,4 +1,5 @@
-require 'spec/rake/spectask'
+gem 'rspec', '2.0.0.beta.1'
+require 'rspec/core/rake_task'
 
 begin
   require 'jeweler'
@@ -18,12 +19,12 @@ end
 
 desc 'Default: run specs'
 task :default => :spec
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = FileList["spec/**/*_spec.rb"]
+Rspec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
 end
 
-Spec::Rake::SpecTask.new('rcov') do |t|
-  t.spec_files = FileList["spec/**/*_spec.rb"]
+Rspec::Core::RakeTask.new('rcov') do |t|
+  t.pattern = "spec/**/*_spec.rb"
   t.rcov = true
   t.rcov_opts = ['--exclude', 'spec']
 end

data/VERSION

@@ -1 +1 @@
-1.1.9
+2.0.0.pre1

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

@@ -1,7 +1,27 @@
-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'
+begin
+  # Try to require the preresolved locked set of gems.
+  require File.expand_path("../.bundle/environment", __FILE__)
+rescue LoadError
+  # Fall back on doing an unlocked resolve at runtime.
+  require "rubygems"
+  require "bundler"
+  Bundler.setup
+end
+
+Bundler.require
+
+require "active_record"
+require "action_view"
+
+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"
+
+ActiveRecord::Base.send :include, ActiveRecord::Acts::TaggableOn
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Tagger
+
+ActionView::Base.send :include, TagsHelper

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -1,11 +1,13 @@
 module ActiveRecord
   module Acts
     module TaggableOn
+
       def self.included(base)
         base.extend(ClassMethods)
       end
 
       module ClassMethods
+
         def taggable?
           false
         end
@@ -17,6 +19,7 @@ module ActiveRecord
         def acts_as_taggable_on(*args)
           args.flatten! if args
           args.compact! if args
+
           for tag_type in args
             tag_type = tag_type.to_s
             # use aliased_join_table_name for context condition so that sphinx can join multiple
@@ -28,6 +31,7 @@ module ActiveRecord
             end
 
             class_eval <<-RUBY
+
               def self.taggable?
                 true
               end
@@ -43,10 +47,6 @@ module ActiveRecord
               def #{tag_type.singularize}_list
                 tag_list_on('#{tag_type}')
               end
-              
-              def all_#{tag_type}_list
-                all_tags_list_on('#{tag_type}')
-              end
 
               def #{tag_type.singularize}_list=(new_tags)
                 set_tag_list_on('#{tag_type}',new_tags)
@@ -72,7 +72,7 @@ module ActiveRecord
               def find_matching_contexts(search_context, result_context, options = {})
                 matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
               end
-              
+
               def find_matching_contexts_for(klass, search_context, result_context, options = {})
                 matching_contexts_for(search_context.to_s, result_context.to_s, klass, options)
               end
@@ -84,8 +84,10 @@ module ActiveRecord
               def self.top_#{tag_type}(limit = 10)
                 tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
               end
+
             RUBY
           end
+
           if respond_to?(:tag_types)
             write_inheritable_attribute( :tag_types, (tag_types + args).uniq )
           else
@@ -99,23 +101,26 @@ module ActiveRecord
               attr_writer :custom_contexts
 
               before_save :save_cached_tag_list
-              after_save :save_tags
 
-              if respond_to?(:named_scope)
-                named_scope :tagged_with, lambda{ |*args|
-                  find_options_for_find_tagged_with(*args)
-                }
-              end
+              after_save:save_tags
+
+              scope :tagged_with, lambda{ |*args|
+                find_options_for_find_tagged_with(*args)
+              }
             end
 
             include ActiveRecord::Acts::TaggableOn::InstanceMethods
             extend ActiveRecord::Acts::TaggableOn::SingletonMethods
+            alias_method_chain :reload, :tag_list
           end
         end
+
       end
 
       module SingletonMethods
+
         include ActiveRecord::Acts::TaggableOn::GroupHelper
+
         # Pass either a tag string, or an array of strings or tags
         #
         # Options:
@@ -124,21 +129,20 @@ module ActiveRecord
         #   :match_all - Find models that match all of the given tags, not just one
         #   :conditions - A piece of SQL conditions to add to the query
         #   :on - scopes the find to a context
-        def find_tagged_with(*args)
-          options = find_options_for_find_tagged_with(*args)
-          options.blank? ? [] : find(:all,options)
-        end
+        # def find_tagged_with(*args)
+        #   find_options_for_find_tagged_with(*args)
+        # end
 
         def caching_tag_list_on?(context)
           column_names.include?("cached_#{context.to_s.singularize}_list")
         end
 
         def tag_counts_on(context, options = {})
-          Tag.find(:all, find_options_for_tag_counts(options.merge({:on => context.to_s})))
+          find_for_tag_counts(options.merge({:on => context.to_s}))
         end
 
         def all_tag_counts(options = {})
-          Tag.find(:all, find_options_for_tag_counts(options))
+          find_for_tag_counts(options)
         end
 
         def find_options_for_find_tagged_with(tags, options = {})
@@ -151,7 +155,6 @@ module ActiveRecord
 
           context = options.delete(:on)
 
-
           if options.delete(:exclude)
             tags_conditions = tag_list.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)})"
@@ -163,7 +166,7 @@ module ActiveRecord
           else
             tags = Tag.named_any(tag_list)
             return { :conditions => "1 = 0" } unless tags.length == tag_list.length
-                      
+
             tags.each do |tag|
               safe_tag = tag.name.gsub(/[^a-zA-Z0-9]/, '')
               prefix   = "#{safe_tag}_#{rand(1024)}"
@@ -190,10 +193,12 @@ module ActiveRecord
             group = "#{grouped_column_names_for(self)} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
           end
 
-          { :joins      => joins.join(" "),
-            :group      => group,
-            :conditions => conditions.join(" AND "),
-            :readonly   => false }.update(options)
+          Tag.joins(joins.join(" ")).group(group).where(conditions.join(" AND ")).readonly(false)
+
+          # { :joins      => joins.join(" "),
+          #   :group      => group,
+          #   :conditions => conditions.join(" AND "),
+          #   :readonly   => false }.update(options)
         end
 
         # Calculate the tag counts for all tags.
@@ -207,10 +212,9 @@ module ActiveRecord
         #  :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 find_options_for_tag_counts(options = {})
+        def find_for_tag_counts(options = {})
           options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
 
-          scope = scope(:find)
           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]
 
@@ -227,58 +231,34 @@ module ActiveRecord
           ]
 
           conditions = conditions.compact.join(' AND ')
-          conditions = merge_conditions(conditions, scope[:conditions]) if scope
 
           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
 
-          # Based on a proposed patch by donV to ActiveRecord Base
-          # This is needed because merge_joins and construct_join are private in ActiveRecord Base
-          if scope && scope[:joins]
-            case scope[:joins]
-            when Array
-              scope_joins = scope[:joins].flatten
-              strings = scope_joins.select{|j| j.is_a? String}
-              joins << strings.join(' ') + " "
-              symbols = scope_joins - strings
-              join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, symbols, nil)
-              joins << " #{join_dependency.join_associations.collect { |assoc| assoc.association_join }.join} "
-              joins.flatten!
-            when Symbol, Hash
-              join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, scope[:joins], nil)
-              joins << " #{join_dependency.join_associations.collect { |assoc| assoc.association_join }.join} "
-            when String
-              joins << scope[:joins]
-            end
-          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?
 
-          { :select     => "#{Tag.table_name}.*, COUNT(*) AS count",
-            :joins      => joins.join(" "),
-            :conditions => conditions,
-            :group      => group_by,
-            :limit      => options[:limit],
-            :order      => options[:order]
-          }
+          Tag.select("#{Tag.table_name}.*, COUNT(*) AS count").joins(joins.join(" ")).where(conditions).group(group_by).limit(options[:limit]).order(options[:order])
+
         end
 
         def is_taggable?
           true
         end
+
       end
 
       module InstanceMethods
+
         include ActiveRecord::Acts::TaggableOn::GroupHelper
 
         def custom_contexts
@@ -288,7 +268,7 @@ module ActiveRecord
         def is_taggable?
           self.class.is_taggable?
         end
-        
+
         def add_custom_context(value)
           custom_contexts << value.to_s unless custom_contexts.include?(value.to_s) or self.class.tag_types.map(&:to_s).include?(value.to_s)
         end
@@ -297,40 +277,38 @@ module ActiveRecord
           add_custom_context(context)
           cache = tag_list_cache_on(context)
           return owner ? cache[owner] : cache[owner] if cache[owner]
-          
+
           if !owner && self.class.caching_tag_list_on?(context) and !(cached_value = cached_tag_list_on(context)).nil?
             cache[owner] = TagList.from(cached_tag_list_on(context))
           else
             cache[owner] = TagList.new(*tags_on(context, owner).map(&:name))
           end
         end
-        
+
         def all_tags_list_on(context)
           variable_name = "@all_#{context.to_s.singularize}_list"
           return instance_variable_get(variable_name) if instance_variable_get(variable_name)
           instance_variable_set(variable_name, TagList.new(all_tags_on(context).map(&:name)).freeze)
         end
-        
+
         def all_tags_on(context)
-          opts = {:conditions => ["#{Tagging.table_name}.context = ?", context.to_s]}
-          base_tags.find(:all, opts.merge(:order => "#{Tagging.table_name}.created_at"))
+          opts =  ["#{Tagging.table_name}.context = ?", context.to_s]
+          base_tags.where(opts).order("#{Tagging.table_name}.created_at")
         end
 
         def tags_on(context, owner = nil)
           if owner
-            opts = {:conditions => ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id = ? AND #{Tagging.table_name}.tagger_type = ?",
-                                    context.to_s, owner.id, owner.class.to_s]}
+            opts = ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id = ? AND #{Tagging.table_name}.tagger_type = ?", context.to_s, owner.id, owner.class.to_s]
           else
-            opts = {:conditions => ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id IS NULL", context.to_s]}
+            opts = ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id IS NULL", context.to_s]
           end
-
-          base_tags.find(:all, opts)
+          base_tags.where(opts)
         end
 
         def cached_tag_list_on(context)
           self["cached_#{context.to_s.singularize}_list"]
         end
-        
+
         def tag_list_cache_on(context)
           variable_name = "@#{context.to_s.singularize}_list"
           cache = instance_variable_get(variable_name)
@@ -350,7 +328,7 @@ module ActiveRecord
         def related_tags_for(context, klass, options = {})
           search_conditions = related_search_options(context, klass, options)
 
-          klass.find(:all, search_conditions)
+          klass.select(search_conditions[:select]).from(search_conditions[:from]).where(search_conditions[:conditions]).group(search_conditions[:group]).order(search_conditions[:order])
         end
 
         def related_search_options(context, klass, options = {})
@@ -365,13 +343,13 @@ module ActiveRecord
             :order      => "count DESC"
           }.update(options)
         end
-        
+
         def matching_contexts_for(search_context, result_context, klass, options = {})
           search_conditions = matching_context_search_options(search_context, result_context, klass, options)
 
-          klass.find(:all, search_conditions)
+          klass.select(search_conditions[:select]).from(search_conditions[:from]).where(search_conditions[:conditions]).group(search_conditions[:group]).order(search_conditions[:order])
         end
-        
+
         def matching_context_search_options(search_context, result_context, klass, options = {})
           tags_to_find = tags_on(search_context).collect { |t| t.name }
 
@@ -388,7 +366,7 @@ module ActiveRecord
         def save_cached_tag_list
           self.class.tag_types.map(&:to_s).each do |tag_type|
             if self.class.send("caching_#{tag_type.singularize}_list?")
-              send(:"cached_#{tag_type.singularize}_list=", tag_list_cache_on(tag_type.singularize).to_a.flatten.compact.join(', '))
+              self["cached_#{tag_type.singularize}_list"] = tag_list_cache_on(tag_type.singularize).to_a.flatten.compact.join(', ')
             end
           end
         end
@@ -399,28 +377,22 @@ module ActiveRecord
           transaction do
             contexts.each do |context|
               cache = tag_list_cache_on(context)
-              
+
               cache.each do |owner, list|
                 new_tags = Tag.find_or_create_all_with_like_by_name(list.uniq)
-                taggings = Tagging.find(:all, :conditions => { :taggable_id => self.id, :taggable_type => self.class.base_class.to_s })
+                taggings = Tagging.where({ :taggable_id => self.id, :taggable_type => self.class.base_class.to_s })
 
                 # Destroy old taggings:
                 if owner
                   old_tags = tags_on(context, owner) - new_tags
-                  old_taggings = Tagging.find(:all, :conditions => { :taggable_id => self.id, :taggable_type => self.class.base_class.to_s, :tag_id => old_tags, :tagger_id => owner.id, :tagger_type => owner.class.to_s, :context => context })
+                  old_taggings = Tagging.where({ :taggable_id => self.id, :taggable_type => self.class.base_class.to_s, :tag_id => old_tags, :tagger_id => owner.id, :tagger_type => owner.class.to_s, :context => context })
 
-                  if old_taggings.present?
-                    Tagging.destroy_all :id => old_taggings.map(&:id)
-                  end
+                  Tagging.destroy_all :id => old_taggings.map(&:id)
                 else
                   old_tags = tags_on(context) - new_tags
-                  old_taggings = Tagging.find(:all, :conditions => { :taggable_id => self.id, :taggable_type => self.class.base_class.to_s, :tag_id => old_tags, :tagger_id => nil, :tagger_type => nil, :context => context })
-                  
-                  if old_taggings.present?
-                    Tagging.destroy_all :id => old_taggings.map(&:id)
-                  end           
+                  base_tags.delete(*old_tags)
                 end
- 
+
                 new_tags.reject! { |tag| taggings.any? { |tagging|
                     tagging.tag_id      == tag.id &&
                     tagging.tagger_id   == (owner ? owner.id : nil) &&
@@ -428,17 +400,26 @@ module ActiveRecord
                     tagging.context     == context
                   }
                 }
-                
+
                 # create new taggings:
                 new_tags.each do |tag|
                   Tagging.create!(:tag_id => tag.id, :context => context, :tagger => owner, :taggable => self)
                 end
               end
             end
-          end          
+          end
 
           true
         end
+
+        def reload_with_tag_list(*args)
+          self.class.tag_types.each do |tag_type|
+            instance_variable_set("@#{tag_type.to_s.singularize}_list", nil)
+          end
+
+          reload_without_tag_list(*args)
+        end
+
       end
     end
   end