acts-as-taggable-on 2.0.6 → 2.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.log
+*.sqlite3
+/pkg/*
+.bundle
+.rvmrc
+Gemfile.lock
+spec/database.yml

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--backtrace

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,10 +1,3 @@
-source :gemcutter
+source 'http://rubygems.org'
+gemspec
 
-# Rails 3.0
-gem 'rails',        '3.0.0.beta3'
-gem 'rspec',        '2.0.0.beta.8'
-gem 'sqlite3-ruby', :require => 'sqlite3'
-gem 'mysql'
-gem 'pg'
-gem 'jeweler'
-gem 'rcov'

data/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

@@ -96,7 +96,7 @@ 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,7 +108,10 @@ compatibility with the will_paginate gem:
     
     # Find a user with any of the tags:
     User.tagged_with(["awesome", "cool"], :any => true)
-
+    
+    # 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.

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/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.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,6 +25,7 @@ require "acts_as_taggable_on/tagging"
 
 $LOAD_PATH.shift
 
+
 if defined?(ActiveRecord::Base)
   ActiveRecord::Base.extend ActsAsTaggableOn::Taggable
   ActiveRecord::Base.send :include, ActsAsTaggableOn::Tagger

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/acts_as_taggable_on.rb

@@ -28,10 +28,19 @@ module ActsAsTaggableOn
       tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
 
       if taggable?
-        write_inheritable_attribute(:tag_types, (self.tag_types + tag_types).uniq)
+        if RAILS_3
+          self.tag_types = (self.tag_types + tag_types).uniq        
+        else
+          write_inheritable_attribute(:tag_types, (self.tag_types + tag_types).uniq)                  
+        end
       else
-        write_inheritable_attribute(:tag_types, tag_types)
-        class_inheritable_reader(:tag_types)
+        if RAILS_3
+          class_attribute :tag_types
+          self.tag_types = tag_types
+        else
+          write_inheritable_attribute(:tag_types, tag_types)
+          class_inheritable_reader(:tag_types)
+        end
         
         class_eval do
           has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging"
@@ -40,7 +49,8 @@ module ActsAsTaggableOn
           def self.taggable?
             true
           end
-        
+          
+          include ActsAsTaggableOn::Utils        
           include ActsAsTaggableOn::Taggable::Core
           include ActsAsTaggableOn::Taggable::Collection
           include ActsAsTaggableOn::Taggable::Cache

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -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)

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -61,65 +61,72 @@ module ActsAsTaggableOn::Taggable
 
         ## Generate conditions:
         options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]     
-          
+
         start_at_conditions = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
         end_at_conditions   = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
-
+        
         taggable_conditions  = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.taggable_type = ?", base_class.name])
-        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = ?", options.delete(:id)]) if options[:id]
-
-        conditions = [
+        taggable_conditions << 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 #{ActsAsTaggableOn::Tagging.table_name} ON #{ActsAsTaggableOn::Tag.table_name}.id = #{ActsAsTaggableOn::Tagging.table_name}.tag_id"
-        tagging_join << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
-
         taggable_join = "INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id"
         taggable_join << " AND #{table_name}.#{inheritance_column} = '#{name}'" unless descends_from_active_record? # Current model is STI descendant, so add type checking to the join condition      
 
-        joins = [
-          tagging_join,
+        tagging_joins = [
           taggable_join,
           scope[:joins]
         ].compact
 
-        joins = joins.reverse if ActiveRecord::VERSION::MAJOR < 3
+        tag_joins = [
+        ].compact
 
+        [tagging_joins, tag_joins].each(&:reverse!) if ActiveRecord::VERSION::MAJOR < 3
 
         ## Generate scope:
-        scope = ActsAsTaggableOn::Tag.scoped(:select => "#{ActsAsTaggableOn::Tag.table_name}.*, COUNT(*) AS count").order(options[:order]).limit(options[:limit])   
-        
+        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("#{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)
+          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(ActsAsTaggableOn::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
@@ -21,7 +21,7 @@ module ActsAsTaggableOn::Taggable
 
           class_eval do
             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]
+            :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
 
@@ -67,31 +67,51 @@ module ActsAsTaggableOn::Taggable
       #   User.tagged_with("awesome", "cool", :match_all => true) # Users that are tagged with just awesome and cool
       def tagged_with(tags, options = {})
         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(["#{ActsAsTaggableOn::Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
+          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(["#{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)})"
+          # 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 = ActsAsTaggableOn::Tag.named_any(tag_list)
-          return scoped(:conditions => "1 = 0") unless tags.length == tag_list.length
+          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 #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
                             "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
@@ -103,18 +123,20 @@ 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 #{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],
@@ -176,8 +198,17 @@ module ActsAsTaggableOn::Taggable
         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
+        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
 
       ##
@@ -238,4 +269,4 @@ module ActsAsTaggableOn::Taggable
       end
     end
   end
-end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -30,9 +30,13 @@ module ActsAsTaggableOn::Taggable
     
     module InstanceMethods
       def owner_tags_on(owner, context)
-        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
+        if owner.nil?
+          base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ?), context.to_s]).all                    
+        else
+          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
       end
 
       def cached_owned_tag_list_on(context)

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -18,7 +18,11 @@ module ActsAsTaggableOn::Taggable
             def find_related_#{tag_type}_for(klass, options = {})
               related_tags_for('#{tag_type}', klass, options)
             end
-
+          )
+        end
+        
+        unless tag_types.empty?
+          class_eval %(
             def find_matching_contexts(search_context, result_context, options = {})
               matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
             end
@@ -42,10 +46,12 @@ module ActsAsTaggableOn::Taggable
 
         exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
         
+        group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
+        
         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),
+                       :group      => group_columns,
                        :order      => "count DESC" }.update(options))
       end
       
@@ -54,10 +60,12 @@ module ActsAsTaggableOn::Taggable
 
         exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
 
+group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
+
         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),
+                       :group      => group_columns,
                        :order      => "count DESC" }.update(options))
       end
     end

data/lib/acts_as_taggable_on/compatibility/Gemfile

@@ -4,5 +4,5 @@ source :gemcutter
 gem 'rails',        '2.3.5'
 gem 'rspec',        '1.3.0', :require => 'spec'
 gem 'sqlite3-ruby', '1.2.5', :require => 'sqlite3'
-gem 'mysql'
+gem 'mysql2',       '~> 0.2.7'
 gem 'pg'

data/lib/acts_as_taggable_on/compatibility/active_record_backports.rb

@@ -9,7 +9,11 @@ module ActsAsTaggableOn
           named_scope :order,    lambda { |order|      { :order => order } }
           named_scope :select,   lambda { |select|     { :select => select } }
           named_scope :limit,    lambda { |limit|      { :limit => limit } }
-          named_scope :readonly, lambda { |readonly|   { :readonly => readonly } }   
+          named_scope :readonly, lambda { |readonly|   { :readonly => readonly } }
+          
+          def self.to_sql
+            construct_finder_sql({})
+          end
         end
       end
     end

data/lib/acts_as_taggable_on/tag.rb

@@ -1,7 +1,8 @@
 module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
     include ActsAsTaggableOn::ActiveRecord::Backports if ::ActiveRecord::VERSION::MAJOR < 3
-  
+    include ActsAsTaggableOn::Utils
+      
     attr_accessible :name
 
     ### ASSOCIATIONS:
@@ -14,21 +15,21 @@ module ActsAsTaggableOn
     validates_uniqueness_of :name
 
     ### SCOPES:
-
+    
     def self.named(name)
-      where(["name #{like_operator} ?", name])
+      where(["name #{like_operator} ?", escape_like(name)])
     end
   
     def self.named_any(list)
-      where(list.map { |tag| sanitize_sql(["name #{like_operator} ?", tag.to_s]) }.join(" OR "))
+      where(list.map { |tag| sanitize_sql(["name #{like_operator} ?", escape_like(tag.to_s)]) }.join(" OR "))
     end
   
     def self.named_like(name)
-      where(["name #{like_operator} ?", "%#{name}%"])
+      where(["name #{like_operator} ?", "%#{escape_like(name)}%"])
     end
 
     def self.named_like_any(list)
-      where(list.map { |tag| sanitize_sql(["name #{like_operator} ?", "%#{tag.to_s}%"]) }.join(" OR "))
+      where(list.map { |tag| sanitize_sql(["name #{like_operator} ?", "%#{escape_like(tag.to_s)}%"]) }.join(" OR "))
     end
 
     ### CLASS METHODS:
@@ -43,7 +44,10 @@ module ActsAsTaggableOn
       return [] if list.empty?
 
       existing_tags = Tag.named_any(list).all
-      new_tag_names = list.reject { |name| existing_tags.any? { |tag| tag.name.mb_chars.downcase == name.mb_chars.downcase } }
+      new_tag_names = list.reject do |name| 
+                        name = comparable_name(name)
+                        existing_tags.any? { |tag| comparable_name(tag.name) == name }
+                      end
       created_tags  = new_tag_names.map { |name| Tag.create(:name => name) }
 
       existing_tags + created_tags
@@ -62,13 +66,16 @@ module ActsAsTaggableOn
     def count
       read_attribute(:count).to_i
     end
-
+    
+    def safe_name
+      name.gsub(/[^a-zA-Z0-9]/, '')
+    end
+    
     class << self
-      private
-        def like_operator
-          connection.adapter_name == 'PostgreSQL' ? 'ILIKE' : 'LIKE'
+      private        
+        def comparable_name(str)
+          RUBY_VERSION >= "1.9" ? str.downcase : str.mb_chars.downcase
         end
     end
-
   end
 end

data/lib/acts_as_taggable_on/utils.rb

@@ -0,0 +1,31 @@
+module ActsAsTaggableOn
+  module Utils
+    def self.included(base)
+      
+      base.send :include, ActsAsTaggableOn::Utils::OverallMethods
+      base.extend ActsAsTaggableOn::Utils::OverallMethods      
+    end
+
+    module OverallMethods
+      def using_postgresql?
+        ::ActiveRecord::Base.connection && ::ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+      end
+      
+      def using_sqlite?
+        ::ActiveRecord::Base.connection && ::ActiveRecord::Base.connection.adapter_name == 'SQLite'
+      end 
+        
+      private
+      def like_operator
+        using_postgresql? ? 'ILIKE' : 'LIKE'
+      end
+      
+      # escape _ and % characters in strings, since these are wildcards in SQL.
+       def escape_like(str)
+         return str if using_sqlite? # skip escaping for SQLite
+         str.to_s.gsub("_", "\\\_").gsub("%", "\\\%")
+       end
+    end
+
+  end
+end

data/lib/generators/acts_as_taggable_on/migration/migration_generator.rb

@@ -19,7 +19,7 @@ module ActsAsTaggableOn
     end
 
     def self.next_migration_number(path)
-      Time.now.utc.strftime("%Y%m%d%H%M%S")
+      ActiveRecord::Generators::Base.next_migration_number(path)
     end
 
     def create_migration_file

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -12,7 +12,7 @@ describe "Acts As Taggable On" do
   describe "Taggable Method Generation" do
     before(:each) do
       clean_database!
-      TaggableModel.write_inheritable_attribute(:tag_types, [])
+      RAILS_3 ? TaggableModel.tag_types = [] : TaggableModel.write_inheritable_attribute(:tag_types, [])
       TaggableModel.acts_as_taggable_on(:tags, :languages, :skills, :needs, :offerings)
       @taggable = TaggableModel.new(:name => "Bob Jones")
     end
@@ -212,24 +212,36 @@ describe "Acts As Taggable On" do
   describe 'Caching' do
     before(:each) do
       @taggable = CachedModel.new(:name => "Bob Jones")  
+      @another_taggable = OtherCachedModel.new(:name => "John Smith")
     end
     
     it "should add saving of tag lists and cached tag lists to the instance" do
       @taggable.should respond_to(:save_cached_tag_list)
+      @another_taggable.should respond_to(:save_cached_tag_list)
+      
       @taggable.should respond_to(:save_tags)
     end  
 
+    it "should add cached tag lists to the instance if cached column is not present" do
+      TaggableModel.new(:name => "Art Kram").should_not respond_to(:save_cached_tag_list)
+    end
+    
     it "should generate a cached column checker for each tag type" do
       CachedModel.should respond_to(:caching_tag_list?)
+      OtherCachedModel.should respond_to(:caching_language_list?)
     end  
     
     it 'should not have cached tags' do
       @taggable.cached_tag_list.should be_blank  
+      @another_taggable.cached_language_list.should be_blank      
     end
     
     it 'should cache tags' do
       @taggable.update_attributes(:tag_list => 'awesome, epic')
       @taggable.cached_tag_list.should == 'awesome, epic'
+      
+      @another_taggable.update_attributes(:language_list => 'ruby, .net')
+      @another_taggable.cached_language_list.should == 'ruby, .net'      
     end
     
     it 'should keep the cache' do
@@ -265,4 +277,13 @@ describe "Acts As Taggable On" do
     end
   end
 
+  describe "taggings" do 
+    before(:each) do
+      @taggable = TaggableModel.new(:name => "Art Kram")
+    end
+    
+    it 'should return [] taggings' do
+      @taggable.taggings.should == []
+    end
+  end
 end

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -112,4 +112,24 @@ describe ActsAsTaggableOn::Tag do
     @another_tag = ActsAsTaggableOn::Tag.create!(:name => "coolip")
     ActsAsTaggableOn::Tag.named_like('cool').should include(@tag, @another_tag)
   end
+  
+  describe "escape wildcard symbols in like requests" do
+    before(:each) do
+      @tag.name = "cool"
+      @tag.save
+      @another_tag = ActsAsTaggableOn::Tag.create!(:name => "coo%") 
+      @another_tag2 = ActsAsTaggableOn::Tag.create!(:name => "coolish")           
+    end
+    
+    it "return escaped result when '%' char present in tag" do
+      if @tag.using_sqlite?
+        ActsAsTaggableOn::Tag.named_like('coo%').should include(@tag)     
+        ActsAsTaggableOn::Tag.named_like('coo%').should include(@another_tag)
+      else
+        ActsAsTaggableOn::Tag.named_like('coo%').should_not include(@tag)     
+        ActsAsTaggableOn::Tag.named_like('coo%').should include(@another_tag)
+      end
+    end
+    
+  end
 end

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -4,6 +4,7 @@ describe "Taggable" do
   before(:each) do
     clean_database!
     @taggable = TaggableModel.new(:name => "Bob Jones")
+    @taggables = [@taggable, TaggableModel.new(:name => "John Doe")]
   end
 
   it "should have tag types" do
@@ -68,6 +69,22 @@ describe "Taggable" do
     @taggable.should have(2).skills
   end
 
+  it "should be able to select taggables by subset of tags using ActiveRelation methods" do
+    @taggables[0].tag_list = "bob"
+    @taggables[1].tag_list = "charlie"
+    @taggables[0].skill_list = "ruby"
+    @taggables[1].skill_list = "css"
+    @taggables.each{|taggable| taggable.save}
+    
+    @found_taggables_by_tag = TaggableModel.joins(:tags).where(:tags => {:name => ["bob"]})
+    @found_taggables_by_skill = TaggableModel.joins(:skills).where(:tags => {:name => ["ruby"]})
+
+    @found_taggables_by_tag.should include @taggables[0]
+    @found_taggables_by_tag.should_not include @taggables[1]
+    @found_taggables_by_skill.should include @taggables[0]
+    @found_taggables_by_skill.should_not include @taggables[1]
+  end
+  
   it "should be able to find by tag" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.save
@@ -111,6 +128,15 @@ describe "Taggable" do
     TaggableModel.all_tag_counts(:order => 'tags.id').first.count.should == 3 # ruby
   end
 
+  it "should be able to use named scopes to chain tag finds by any tags by context" do
+    bob   = TaggableModel.create(:name => "Bob",   :need_list => "rails", :offering_list => "c++")
+    frank = TaggableModel.create(:name => "Frank", :need_list => "css",   :offering_list => "css")
+    steve = TaggableModel.create(:name => 'Steve', :need_list => "c++",   :offering_list => "java")
+
+    # Let's only find those who need rails or css and are offering c++ or java
+    TaggableModel.tagged_with(['rails, css'], :on => :needs, :any => true).tagged_with(['c++', 'java'], :on => :offerings, :any => true).to_a.should == [bob]
+  end
+  
   if ActiveRecord::VERSION::MAJOR >= 3
     it "should not return read-only records" do
       TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
@@ -234,6 +260,12 @@ describe "Taggable" do
 
     TaggableModel.tagged_with("lazy", :exclude => true).to_a.should == [frank, steve]
   end
+  
+  it "should return an empty scope for empty tags" do
+    TaggableModel.tagged_with('').should == []
+    TaggableModel.tagged_with(' ').should == []
+    TaggableModel.tagged_with(nil).should == []    
+  end
 
   it "should not create duplicate taggings" do
     bob = TaggableModel.create(:name => "Bob")

data/spec/acts_as_taggable_on/utils_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe ActsAsTaggableOn::Utils do
+  describe "like_operator" do
+    before(:each) do
+      clean_database!
+      TaggableModel.write_inheritable_attribute(:tag_types, [])
+      TaggableModel.acts_as_taggable_on(:tags, :languages, :skills, :needs, :offerings)
+      @taggable = TaggableModel.new(:name => "Bob Jones")
+    end
+  
+    it "should return 'ILIKE' when the adapter is PostgreSQL" do
+      TaggableModel.connection.stub(:adapter_name).and_return("PostgreSQL")
+      TaggableModel.send(:like_operator).should == "ILIKE"
+    end
+  
+    it "should return 'LIKE' when the adapter is not PostgreSQL" do
+      TaggableModel.connection.stub(:adapter_name).and_return("MySQL")
+      TaggableModel.send(:like_operator).should == "LIKE"
+    end
+  end
+end

data/spec/database.yml.sample

@@ -3,15 +3,17 @@ sqlite3:
   database: acts_as_taggable_on.sqlite3
 
 mysql:
-  adapter: mysql
+  adapter: mysql2
   hostname: localhost
   username: root
   password:
   database: acts_as_taggable_on
-
+  charset: utf8
+  
 postgresql:
   adapter: postgresql
   hostname: localhost
   username: postgres
   password:
   database: acts_as_taggable_on
+  encoding: utf8

data/spec/models.rb

@@ -10,6 +10,10 @@ class CachedModel < ActiveRecord::Base
   acts_as_taggable
 end
 
+class OtherCachedModel < ActiveRecord::Base
+  acts_as_taggable_on :languages
+end
+
 class OtherTaggableModel < ActiveRecord::Base
   acts_as_taggable_on :tags, :languages
   acts_as_taggable_on :needs, :offerings

data/spec/schema.rb

@@ -32,6 +32,12 @@ ActiveRecord::Schema.define :version => 0 do
     t.column :cached_tag_list, :string
   end
   
+  create_table :other_cached_models, :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+    t.column :cached_language_list, :string    
+  end
+  
   create_table :taggable_users, :force => true do |t|
     t.column :name, :string
   end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 $LOAD_PATH << "." unless $LOAD_PATH.include?(".")
+require 'logger'
 
 begin
   require "rubygems"
@@ -13,7 +14,7 @@ begin
   Bundler.setup
 rescue Bundler::GemNotFound
   raise RuntimeError, "Bundler couldn't find some gems." +
-    "Did you run `bundle install`?"
+    "Did you run \`bundlee install\`?"
 end
 
 Bundler.require
@@ -29,14 +30,33 @@ unless [].respond_to?(:freq)
   end
 end
 
-ENV['DB'] ||= 'sqlite3'
-
+db_name = ENV['DB'] || 'sqlite3'
 database_yml = File.expand_path('../database.yml', __FILE__)
+
 if File.exists?(database_yml)
-  active_record_configuration = YAML.load_file(database_yml)[ENV['DB']]
+  active_record_configuration = YAML.load_file(database_yml)
   
-  ActiveRecord::Base.establish_connection(active_record_configuration)
+  ActiveRecord::Base.configurations = active_record_configuration
+  config = ActiveRecord::Base.configurations[db_name]
+  
+  begin
+    ActiveRecord::Base.establish_connection(db_name)
+    ActiveRecord::Base.connection
+  rescue
+    case db_name
+    when /mysql/      
+      ActiveRecord::Base.establish_connection(config.merge('database' => nil))
+      ActiveRecord::Base.connection.create_database(config['database'],  {:charset => 'utf8', :collation => 'utf8_unicode_ci'})
+    when 'postgresql'
+      ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+      ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => 'utf8'))
+    end
+    
+    ActiveRecord::Base.establish_connection(config)
+  end
+    
   ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+  ActiveRecord::Base.default_timezone = :utc
   
   ActiveRecord::Base.silence do
     ActiveRecord::Migration.verbose = false
@@ -57,4 +77,4 @@ def clean_database!
   end
 end
 
-clean_database!
+clean_database!

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-taggable-on
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: 11
+  prerelease: 
   segments: 
   - 2
+  - 1
   - 0
-  - 6
-  version: 2.0.6
+  version: 2.1.0
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -14,28 +15,133 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-19 00:00:00 +02:00
+date: 2010-05-19 00:00:00 +03:00
 default_executable: 
-dependencies: []
-
-description: With ActsAsTaggableOn, you could tag a single model on several contexts, such as skills, interests, and awards. It also provides other advanced functionality.
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: rails
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 5
+        version: "2.5"
+  prerelease: false
+  name: rspec
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: sqlite3
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 0
+        - 3
+        version: "0.3"
+  prerelease: false
+  name: mysql2
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: pg
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: guard
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: guard-rspec
+  type: :development
+  version_requirements: *id007
+description: With ActsAsTaggableOn, you can tag a single model on several contexts, such as skills, interests, and awards. It also provides other advanced functionality.
 email: michael@intridea.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
+- .gitignore
+- .rspec
+- .travis.yml
 - CHANGELOG
 - Gemfile
+- Guardfile
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
+- acts-as-taggable-on.gemspec
 - generators/acts_as_taggable_on_migration/acts_as_taggable_on_migration_generator.rb
 - generators/acts_as_taggable_on_migration/templates/migration.rb
 - lib/acts-as-taggable-on.rb
+- lib/acts-as-taggable-on/version.rb
 - lib/acts_as_taggable_on/acts_as_taggable_on.rb
 - lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb
 - lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb
@@ -45,11 +151,11 @@ files:
 - lib/acts_as_taggable_on/acts_as_tagger.rb
 - lib/acts_as_taggable_on/compatibility/Gemfile
 - lib/acts_as_taggable_on/compatibility/active_record_backports.rb
-- lib/acts_as_taggable_on/compatibility/postgresql.rb
 - lib/acts_as_taggable_on/tag.rb
 - lib/acts_as_taggable_on/tag_list.rb
 - lib/acts_as_taggable_on/tagging.rb
 - lib/acts_as_taggable_on/tags_helper.rb
+- lib/acts_as_taggable_on/utils.rb
 - lib/generators/acts_as_taggable_on/migration/migration_generator.rb
 - lib/generators/acts_as_taggable_on/migration/templates/active_record/migration.rb
 - rails/init.rb
@@ -61,42 +167,47 @@ files:
 - spec/acts_as_taggable_on/tagger_spec.rb
 - spec/acts_as_taggable_on/tagging_spec.rb
 - spec/acts_as_taggable_on/tags_helper_spec.rb
+- spec/acts_as_taggable_on/utils_spec.rb
 - spec/bm.rb
-- spec/database.yml
 - spec/database.yml.sample
 - spec/models.rb
 - spec/schema.rb
 - spec/spec_helper.rb
+- uninstall.rb
 has_rdoc: true
-homepage: http://github.com/mbleigh/acts-as-taggable-on
+homepage: ""
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
-summary: ActsAsTaggableOn is a tagging plugin for Rails that provides multiple tagging contexts on a single model.
+summary: Advanced tagging for Rails.
 test_files: 
 - spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb
 - spec/acts_as_taggable_on/acts_as_tagger_spec.rb
@@ -106,7 +217,9 @@ test_files:
 - spec/acts_as_taggable_on/tagger_spec.rb
 - spec/acts_as_taggable_on/tagging_spec.rb
 - spec/acts_as_taggable_on/tags_helper_spec.rb
+- spec/acts_as_taggable_on/utils_spec.rb
 - spec/bm.rb
+- spec/database.yml.sample
 - spec/models.rb
 - spec/schema.rb
 - spec/spec_helper.rb

data/lib/acts_as_taggable_on/compatibility/postgresql.rb

@@ -1,44 +0,0 @@
-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

data/spec/database.yml

@@ -1,17 +0,0 @@
-sqlite3:
-  adapter: sqlite3
-  database: acts_as_taggable_on.sqlite3
-
-mysql:
-  adapter: mysql
-  hostname: localhost
-  username: root
-  password:
-  database: acts_as_taggable_on
-
-postgresql:
-  adapter: postgresql
-  hostname: localhost
-  username: postgres
-  password:
-  database: acts_as_taggable_on