acts-as-taggable-on 2.0.0 → 2.0.6

data/Gemfile

@@ -1,6 +1,10 @@
 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'
+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

@@ -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,7 +89,7 @@ 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
@@ -109,7 +109,7 @@ compatibility with the will_paginate gem:
     # 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 
@@ -128,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!)
@@ -139,9 +139,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 +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
@@ -174,7 +174,7 @@ Here is an example that generates a tag cloud.
 Helper:
 
   module PostsHelper
-    include TagsHelper
+    include ActsAsTaggableOn::TagsHelper
   end
 
 Controller:
@@ -198,7 +198,7 @@ CSS:
   .css3 { font-size: 1.4em; }
   .css4 { font-size: 1.6em; }
 
-= Contributors
+== Contributors
 
 * TomEric (i76) - Maintainer
 * Michael Bleigh - Original Author
@@ -208,7 +208,7 @@ CSS:
 * Pradeep Elankumaran - Taggers
 * Sinclair Bain - Patch King
 
-== Patch Contributors
+=== Patch Contributors
 
 * tristanzdunn - Related objects of other classes
 * azabaj - Fixed migrate down

data/VERSION

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

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

@@ -26,5 +26,5 @@ if defined?(ActiveRecord::Base)
 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
@@ -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,73 @@ 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(["#{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_type,
-          taggable_id,
+          taggable_conditions,
           options[:conditions],
-          start_at,
-          end_at
-        ]
+          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]
 
-        conditions = conditions.compact.join(' AND ')
+        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 = ["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
+
+        joins = joins.reverse if ActiveRecord::VERSION::MAJOR < 3
 
-        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 = 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 ')
-        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("#{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
 
-        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/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -20,9 +20,9 @@ module ActsAsTaggableOn::Taggable
           context_tags     = tags_type.to_sym
 
           class_eval do
-            has_many context_taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "Tagging",
-                     :conditions => ['#{Tagging.table_name}.tagger_id IS NULL AND #{Tagging.table_name}.context = ?', tags_type]
-            has_many context_tags, :through => context_taggings, :source => :tag
+            has_many context_taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging",
+                     :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.tagger_id IS NULL AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_type]
+            has_many context_tags, :through => context_taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
           end
 
           class_eval %(
@@ -66,7 +66,7 @@ module ActsAsTaggableOn::Taggable
       #   User.tagged_with("awesome", "cool", :any => true)       # Users that are tagged with awesome or cool
       #   User.tagged_with("awesome", "cool", :match_all => true) # Users that are tagged with just awesome and cool
       def tagged_with(tags, options = {})
-        tag_list = TagList.from(tags)
+        tag_list = ActsAsTaggableOn::TagList.from(tags)
 
         return {} if tag_list.empty?
 
@@ -76,16 +76,16 @@ module ActsAsTaggableOn::Taggable
         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)})"
+          tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
+          conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
 
         elsif options.delete(:any)
-          tags_conditions = tag_list.map { |t| sanitize_sql(["#{Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
-          conditions << "#{table_name}.#{primary_key} 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)})"
+          tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
+          conditions << "#{table_name}.#{primary_key} IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
 
         else
-          tags = Tag.named_any(tag_list)
-          return where("1 = 0") unless tags.length == tag_list.length
+          tags = ActsAsTaggableOn::Tag.named_any(tag_list)
+          return scoped(:conditions => "1 = 0") unless tags.length == tag_list.length
 
           tags.each do |tag|
             safe_tag = tag.name.gsub(/[^a-zA-Z0-9]/, '')
@@ -93,7 +93,7 @@ module ActsAsTaggableOn::Taggable
 
             taggings_alias = "#{table_name}_taggings_#{prefix}"
 
-            tagging_join  = "JOIN #{Tagging.table_name} #{taggings_alias}" +
+            tagging_join  = "JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
                             "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
                             " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}" +
                             " AND #{taggings_alias}.tag_id = #{tag.id}"
@@ -106,7 +106,7 @@ module ActsAsTaggableOn::Taggable
         taggings_alias, tags_alias = "#{table_name}_taggings_group", "#{table_name}_tags_group"
 
         if options.delete(:match_all)
-          joins << "LEFT OUTER JOIN #{Tagging.table_name} #{taggings_alias}" +
+          joins << "LEFT OUTER JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
                    "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
                    " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}"
 
@@ -117,6 +117,7 @@ module ActsAsTaggableOn::Taggable
         scoped(:joins      => joins.join(" "),
                :group      => group,
                :conditions => conditions.join(" AND "),
+               :order      => options[:order],
                :readonly   => false)
       end
 
@@ -154,7 +155,7 @@ module ActsAsTaggableOn::Taggable
 
       def tag_list_cache_on(context)
         variable_name = "@#{context.to_s.singularize}_list"
-        instance_variable_get(variable_name) || instance_variable_set(variable_name, TagList.new(tags_on(context).map(&:name)))
+        instance_variable_get(variable_name) || instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
       end
 
       def tag_list_on(context)
@@ -166,40 +167,43 @@ module ActsAsTaggableOn::Taggable
         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)
+        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(all_tags_on(context).map(&:name)).freeze)
       end
 
       ##
       # Returns all tags of a given context
       def all_tags_on(context)
-        opts =  ["#{Tagging.table_name}.context = ?", context.to_s]
-        base_tags.where(opts).order("#{Tagging.table_name}.created_at").group("#{Tagging.table_name}.tag_id").all
+        tag_table_name = ActsAsTaggableOn::Tag.table_name
+        tagging_table_name = ActsAsTaggableOn::Tagging.table_name
+
+        opts =  ["#{tagging_table_name}.context = ?", context.to_s]
+        base_tags.where(opts).order("max(#{tagging_table_name}.created_at)").group("#{tag_table_name}.id, #{tag_table_name}.name").all
       end
 
       ##
       # Returns all tags that are not owned of a given context
       def tags_on(context)
-        base_tags.where(["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id IS NULL", context.to_s]).all
+        base_tags.where(["#{ActsAsTaggableOn::Tagging.table_name}.context = ? AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id IS NULL", context.to_s]).all
       end
 
       def set_tag_list_on(context, new_list)
         add_custom_context(context)
 
         variable_name = "@#{context.to_s.singularize}_list"
-        instance_variable_set(variable_name, TagList.from(new_list))
+        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.from(new_list))
       end
 
       def tagging_contexts
         custom_contexts + self.class.tag_types.map(&:to_s)
       end
 
-      def reload
+      def reload(*args)
         self.class.tag_types.each do |context|
           instance_variable_set("@#{context.to_s.singularize}_list", nil)
           instance_variable_set("@all_#{context.to_s.singularize}_list", nil)
         end
       
-        super
+        super(*args)
       end
 
       def save_tags
@@ -209,7 +213,7 @@ module ActsAsTaggableOn::Taggable
           tag_list = tag_list_cache_on(context).uniq
 
           # Find existing tags or create non-existing tags:
-          tag_list = Tag.find_or_create_all_with_like_by_name(tag_list)
+          tag_list = ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list)
 
           current_tags = tags_on(context)
           old_tags     = current_tags - tag_list
@@ -221,7 +225,7 @@ module ActsAsTaggableOn::Taggable
 
           if old_taggings.present?
             # Destroy old taggings:
-            Tagging.destroy_all :id => old_taggings.map(&:id)
+            ActsAsTaggableOn::Tagging.destroy_all :id => old_taggings.map(&:id)
           end
 
           # Create new taggings:

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -30,9 +30,9 @@ module ActsAsTaggableOn::Taggable
     
     module InstanceMethods
       def owner_tags_on(owner, context)
-        base_tags.where([%(#{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]).all
+        base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ? AND
+                           #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = ? AND
+                           #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = ?), context.to_s, owner.id, owner.class.to_s]).all
       end
 
       def cached_owned_tag_list_on(context)
@@ -46,7 +46,7 @@ module ActsAsTaggableOn::Taggable
         cache = cached_owned_tag_list_on(context)
         cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
         
-        cache[owner] ||= TagList.new(*owner_tags_on(owner, context).map(&:name))
+        cache[owner] ||= ActsAsTaggableOn::TagList.new(*owner_tags_on(owner, context).map(&:name))
       end
       
       def set_owner_tag_list_on(owner, context, new_list)
@@ -55,22 +55,22 @@ module ActsAsTaggableOn::Taggable
         cache = cached_owned_tag_list_on(context)
         cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
 
-        cache[owner] = TagList.from(new_list)
+        cache[owner] = ActsAsTaggableOn::TagList.from(new_list)
       end
       
-      def reload
+      def reload(*args)
         self.class.tag_types.each do |context|
           instance_variable_set("@owned_#{context}_list", nil)
         end
       
-        super
+        super(*args)
       end
     
       def save_owned_tags
         tagging_contexts.each do |context|
           cached_owned_tag_list_on(context).each do |owner, tag_list|
             # Find existing tags or create non-existing tags:
-            tag_list = Tag.find_or_create_all_with_like_by_name(tag_list.uniq)            
+            tag_list = ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list.uniq)            
 
             owned_tags = owner_tags_on(owner, context)              
             old_tags   = owned_tags - tag_list
@@ -78,13 +78,13 @@ module ActsAsTaggableOn::Taggable
           
             # Find all taggings that belong to the taggable (self), are owned by the owner, 
             # have the correct context, and are removed from the list.
-            old_taggings = Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
-                                         :tagger_type => owner.class.to_s, :tagger_id => owner.id,
-                                         :tag_id => old_tags, :context => context).all
+            old_taggings = ActsAsTaggableOn::Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
+                                                           :tagger_type => owner.class.to_s, :tagger_id => owner.id,
+                                                           :tag_id => old_tags, :context => context).all
           
             if old_taggings.present?
               # Destroy old taggings:
-              Tagging.destroy_all(:id => old_taggings.map(&:id))
+              ActsAsTaggableOn::Tagging.destroy_all(:id => old_taggings.map(&:id))
             end
 
             # Create new taggings:

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -3,6 +3,7 @@ module ActsAsTaggableOn::Taggable
     def self.included(base)
       base.send :include, ActsAsTaggableOn::Taggable::Related::InstanceMethods
       base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
+      base.initialize_acts_as_taggable_on_related
     end
     
     module ClassMethods
@@ -41,9 +42,9 @@ module ActsAsTaggableOn::Taggable
 
         exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
         
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{Tag.table_name}.id) AS count",
-                       :from       => "#{klass.table_name}, #{Tag.table_name}, #{Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{Tagging.table_name}.taggable_id AND #{Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND #{Tag.table_name}.name IN (?) AND #{Tagging.table_name}.context = ?", tags_to_find, result_context],
+        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.id) AS count",
+                       :from       => "#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}",
+                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context],
                        :group      => grouped_column_names_for(klass),
                        :order      => "count DESC" }.update(options))
       end
@@ -53,9 +54,9 @@ module ActsAsTaggableOn::Taggable
 
         exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
 
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{Tag.table_name}.id) AS count",
-                       :from       => "#{klass.table_name}, #{Tag.table_name}, #{Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{Tagging.table_name}.taggable_id AND #{Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND #{Tag.table_name}.name IN (?)", tags_to_find],
+        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.id) AS count",
+                       :from       => "#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}",
+                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?)", tags_to_find],
                        :group      => grouped_column_names_for(klass),
                        :order      => "count DESC" }.update(options))
       end

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -34,8 +34,8 @@ module ActsAsTaggableOn
         class_inheritable_reader(:tag_types)
         
         class_eval do
-          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag
-          has_many :base_tags, :class_name => "Tag", :through => :taggings, :source => :tag
+          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging"
+          has_many :base_tags, :through => :taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
 
           def self.taggable?
             true

data/lib/acts_as_taggable_on/acts_as_tagger.rb

@@ -16,8 +16,8 @@ module ActsAsTaggableOn
       def acts_as_tagger(opts={})
         class_eval do
           has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy,
-                                               :include => :tag, :class_name => "Tagging")
-          has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true
+                                               :include => :tag, :class_name => "ActsAsTaggableOn::Tagging")
+          has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true, :class_name => "ActsAsTaggableOn::Tag"
         end
 
         include ActsAsTaggableOn::Tagger::InstanceMethods

data/lib/acts_as_taggable_on/compatibility/Gemfile

@@ -3,4 +3,6 @@ source :gemcutter
 # Rails 2.3
 gem 'rails',        '2.3.5'
 gem 'rspec',        '1.3.0', :require => 'spec'
-gem 'sqlite3-ruby', '1.2.5', :require => 'sqlite3'
+gem 'sqlite3-ruby', '1.2.5', :require => 'sqlite3'
+gem 'mysql'
+gem 'pg'

data/lib/acts_as_taggable_on/compatibility/postgresql.rb

@@ -0,0 +1,44 @@
+module ActsAsTaggableOn
+  module Taggable
+    module PostgreSQL
+      def self.included(base)
+        base.send :include, ActsAsTaggableOn::Taggable::PostgreSQL::InstanceMethods
+        base.extend ActsAsTaggableOn::Taggable::PostgreSQL::ClassMethods
+      
+        ActsAsTaggableOn::Tag.class_eval do
+          def self.named(name)
+            where(["name ILIKE ?", name])
+          end
+
+          def self.named_any(list)
+            where(list.map { |tag| sanitize_sql(["name ILIKE ?", tag.to_s]) }.join(" OR "))
+          end
+
+          def self.named_like(name)
+            where(["name ILIKE ?", "%#{name}%"])
+          end
+
+          def self.named_like_any(list)
+            where(list.map { |tag| sanitize_sql(["name ILIKE ?", "%#{tag.to_s}%"]) }.join(" OR "))
+          end          
+        end
+      end
+      
+      module InstanceMethods
+      end
+      
+      module ClassMethods
+        # all column names are necessary for PostgreSQL group clause
+        def grouped_column_names_for(*objects)
+          object   = objects.shift
+          columns  = object.column_names.map { |column| "#{object.table_name}.#{column}" }
+          columns << objects.map do |object|
+                       "#{object.table_name}.created_at"
+                     end.flatten
+
+          columns.flatten.join(", ")
+        end
+      end
+    end
+  end
+end