acts-as-taggable-on 2.0.3 → 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.3
+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

@@ -61,63 +61,72 @@ module ActsAsTaggableOn::Taggable
 
         ## Generate conditions:
         options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]     
-          
-        start_at_conditions = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
-        end_at_conditions   = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
 
-        taggable_conditions  = sanitize_sql(["#{Tagging.table_name}.taggable_type = ?", base_class.name])
-        taggable_conditions << sanitize_sql([" AND #{Tagging.table_name}.taggable_id = ?", options.delete(:id)]) if options[:id]
-
-        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,
-          options[:conditions],
           scope[:conditions],
           start_at_conditions,
           end_at_conditions
         ].compact.reverse
         
+        tag_conditions = [
+          options[:conditions]        
+        ].compact.reverse
+        
         ## Generate joins:
-        tagging_join  = "LEFT OUTER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"
-        tagging_join << sanitize_sql([" AND #{Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
-
-        taggable_join = "INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"
+        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,
+        tagging_joins = [
           taggable_join,
           scope[:joins]
-        ].compact.reverse
+        ].compact
 
+        tag_joins = [
+        ].compact
+
+        [tagging_joins, tag_joins].each(&:reverse!) if ActiveRecord::VERSION::MAJOR < 3
 
         ## Generate scope:
-        scope = Tag.scoped(:select => "#{Tag.table_name}.*, COUNT(*) AS count").order(options[:order]).limit(options[:limit])   
-        
+        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
-        joins.each      { |join|      scope = scope.joins(join)      }
-        conditions.each { |condition| scope = scope.where(condition) }
-        
+        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(['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 ')        
+        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}"
-          scope = scope.where("#{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(Tag)).having(having)
+          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  = "#{grouped_column_names_for(Tag)} HAVING COUNT(*) > 0"
+          group_by  = "#{group_columns} HAVING COUNT(*) > 0"
           group_by << " AND #{having}" unless having.blank?
-          scope = scope.group(group_by)
+          tagging_scope = tagging_scope.group(group_by)
         end
 
-        scope
+        tag_scope = tag_scope.joins("JOIN (#{tagging_scope.to_sql}) AS taggings ON taggings.tag_id = tags.id")
+        tag_scope
       end
     end
     

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -1,5 +1,5 @@
 module ActsAsTaggableOn::Taggable
-  module Core
+  module Core    
     def self.included(base)
       base.send :include, ActsAsTaggableOn::Taggable::Core::InstanceMethods
       base.extend ActsAsTaggableOn::Taggable::Core::ClassMethods
@@ -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}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id 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,34 +66,54 @@ 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)
+        empty_result = scoped(:conditions => "1 = 0")
 
-        return {} if tag_list.empty?
+        return empty_result if tag_list.empty?
 
         joins = []
         conditions = []
 
         context = options.delete(:on)
+        alias_base_name = undecorated_table_name.gsub('.','_')
 
         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_operator} ?", 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)})"
+          # get tags, drop out if nothing returned (we need at least one)
+          tags = ActsAsTaggableOn::Tag.named_any(tag_list)
+          return scoped(:conditions => "1 = 0") unless tags.length > 0
+
+          # setup taggings alias so we can chain, ex: items_locations_taggings_awesome_cool_123
+          # avoid ambiguous column name
+          taggings_context = context ? "_#{context}" : ''
+          
+          #TODO: fix alias to be smaller
+          taggings_alias   = "#{alias_base_name}#{taggings_context}_taggings_#{tags.map(&:safe_name).join('_')}_#{rand(1024)}"
+
+          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)}"
+          tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+
+          # don't need to sanitize sql, map all ids and join with OR logic
+          conditions << tags.map { |t| "#{taggings_alias}.tag_id = #{t.id}" }.join(" OR ")
+          select_clause = "DISTINCT #{table_name}.*" unless context and tag_types.one?
+
+          joins << tagging_join
 
         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 empty_result unless tags.length == tag_list.length
 
           tags.each do |tag|
-            safe_tag = tag.name.gsub(/[^a-zA-Z0-9]/, '')
-            prefix   = "#{safe_tag}_#{rand(1024)}"
+            prefix   = "#{tag.safe_name}_#{rand(1024)}"
 
-            taggings_alias = "#{table_name}_taggings_#{prefix}"
+            taggings_alias = "#{alias_base_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}"
@@ -103,20 +123,23 @@ module ActsAsTaggableOn::Taggable
           end
         end
 
-        taggings_alias, tags_alias = "#{table_name}_taggings_group", "#{table_name}_tags_group"
+        taggings_alias, tags_alias = "#{alias_base_name}_taggings_group", "#{alias_base_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)}"
 
-          group = "#{grouped_column_names_for(self)} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
-        end
 
+          group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
+          group = "#{group_columns} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
+        end
 
-        scoped(:joins      => joins.join(" "),
+        scoped(:select     => select_clause,
+               :joins      => joins.join(" "),
                :group      => group,
                :conditions => conditions.join(" AND "),
+               :order      => options[:order],
                :readonly   => false)
       end
 
@@ -154,7 +177,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 +189,52 @@ 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]
+        scope = base_tags.where(opts)
+        
+        if ActsAsTaggableOn::Tag.using_postgresql?
+          group_columns = grouped_column_names_for(ActsAsTaggableOn::Tag)
+          scope = scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
+        else
+          scope = scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
+        end
+
+        scope.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 +244,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 +256,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:
@@ -234,4 +269,4 @@ module ActsAsTaggableOn::Taggable
       end
     end
   end
-end
+end