acts-as-taggable-on 2.0.0 → 3.2.2

data/Rakefile

@@ -1,59 +1,19 @@
-begin
-  # Rspec 1.3.0
-  require 'spec/rake/spectask'
+require 'rubygems'
+require 'bundler/setup'
 
-  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"  
+desc 'Copy sample spec database.yml over if not exists'
+task :copy_db_config do
+  cp 'spec/internal/config/database.yml.sample', 'spec/internal/config/database.yml'
 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
+task spec: [:copy_db_config]
+
+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/UPGRADING.md

@@ -0,0 +1,13 @@
+When upgrading
+
+Re-run the migrations generator
+
+    rake acts_as_taggable_on_engine:install:migrations
+
+It will create any new migrations and skip existing ones
+
+
+##Breaking changes:
+
+  - ActsAsTaggableOn::Tag is not extend with ActsAsTaggableOn::Utils anymore.
+    Please use ActsAsTaggableOn::Utils instead

data/acts-as-taggable-on.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acts_as_taggable_on/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'acts-as-taggable-on'
+  gem.version       = ActsAsTaggableOn::VERSION
+  gem.authors       = ['Michael Bleigh', 'Joost Baaij']
+  gem.email         = %w(michael@intridea.com joost@spacebabies.nl)
+  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.homepage      = 'https://github.com/mbleigh/acts-as-taggable-on'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ['lib']
+  gem.required_ruby_version     = '>= 1.9.3'
+
+  if File.exist?('UPGRADING.md')
+    gem.post_install_message = File.read('UPGRADING.md')
+  end
+
+  gem.add_runtime_dependency 'activerecord',  ['>= 3', '< 5']
+  gem.add_runtime_dependency 'actionpack',    ['>= 3', '< 5']
+
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'mysql2'
+  gem.add_development_dependency 'pg'
+
+  gem.add_development_dependency 'rspec-rails'  , '~> 3.0.0.beta2'
+  gem.add_development_dependency 'rspec-its', '~> 1.0'
+  gem.add_development_dependency 'rspec', '3.0.0.beta2'
+  gem.add_development_dependency 'ammeter', '~> 1.0'
+  gem.add_development_dependency 'barrier', '~> 1.0'
+  gem.add_development_dependency 'database_cleaner', '~> 1.2'
+end

data/{lib/generators/acts_as_taggable_on/migration/templates/active_record/migration.rb → db/migrate/1_acts_as_taggable_on_migration.rb}

@@ -9,10 +9,12 @@ class ActsAsTaggableOnMigration < ActiveRecord::Migration
 
       # You should make sure that the column created is
       # long enough to store the required class names.
-      t.references :taggable, :polymorphic => true
-      t.references :tagger, :polymorphic => true
+      t.references :taggable, polymorphic: true
+      t.references :tagger, polymorphic: true
 
-      t.string :context
+      # Limit is created to prevent MySQL error on index
+      # length for MyISAM table type: http://bit.ly/vgW2Ql
+      t.string :context, limit: 128
 
       t.datetime :created_at
     end

data/db/migrate/2_add_missing_unique_indices.rb

@@ -0,0 +1,19 @@
+class AddMissingUniqueIndices < ActiveRecord::Migration
+  def self.up
+    add_index :tags, :name, unique: true
+
+    remove_index :taggings, :tag_id
+    remove_index :taggings, [:taggable_id, :taggable_type, :context]
+    add_index :taggings,
+              [:tag_id, :taggable_id, :taggable_type, :context, :tagger_id, :tagger_type],
+              unique: true, name: 'taggings_idx'
+  end
+
+  def self.down
+    remove_index :tags, :name
+
+    remove_index :taggings, name: 'taggings_idx'
+    add_index :taggings, :tag_id
+    add_index :taggings, [:taggable_id, :taggable_type, :context]
+  end
+end

data/db/migrate/3_add_taggings_counter_cache_to_tags.rb

@@ -0,0 +1,14 @@
+class AddTaggingsCounterCacheToTags < ActiveRecord::Migration
+  def self.up
+    add_column :tags, :taggings_count, :integer, default: 0
+
+    ActsAsTaggableOn::Tag.reset_column_information
+    ActsAsTaggableOn::Tag.find_each do |tag|
+      ActsAsTaggableOn::Tag.reset_counters(tag.id, :taggings)
+    end
+  end
+
+  def self.down
+    remove_column :tags, :taggings_count
+  end
+end

data/gemfiles/activerecord_3.2.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 3.2"
+gem "actionpack", "~> 3.2"
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+end
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.0.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.0"
+gem "actionpack", "~> 4.0"
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+end
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.1.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.1"
+gem "actionpack", "~> 4.1"
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+end
+
+gemspec :path => "../"

data/gemfiles/activerecord_edge.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", :github => "rails/rails"
+gem "actionpack", :github => "rails/rails"
+gem "arel", :github => "rails/arel"
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+end
+
+gemspec :path => "../"

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

@@ -1,30 +1,73 @@
-require "active_record"
-require "action_view"
+require 'active_record'
+require 'active_record/version'
+require 'active_support/core_ext/module'
+require 'action_view'
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'digest/sha1'
 
-require "acts_as_taggable_on/compatibility/active_record_backports" if ActiveRecord::VERSION::MAJOR < 3
+module ActsAsTaggableOn
+  class DuplicateTagError < StandardError
+  end
 
-require "acts_as_taggable_on/acts_as_taggable_on"
-require "acts_as_taggable_on/acts_as_taggable_on/core"
-require "acts_as_taggable_on/acts_as_taggable_on/collection"
-require "acts_as_taggable_on/acts_as_taggable_on/cache"
-require "acts_as_taggable_on/acts_as_taggable_on/ownership"
-require "acts_as_taggable_on/acts_as_taggable_on/related"
+  def self.setup
+    @configuration ||= Configuration.new
+    yield @configuration if block_given?
+  end
 
-require "acts_as_taggable_on/acts_as_tagger"
-require "acts_as_taggable_on/tag"
-require "acts_as_taggable_on/tag_list"
-require "acts_as_taggable_on/tags_helper"
-require "acts_as_taggable_on/tagging"
+  def self.method_missing(method_name, *args, &block)
+    @configuration.respond_to?(method_name) ?
+      @configuration.send(method_name, *args, &block) : super
+  end
 
-$LOAD_PATH.shift
+  def self.respond_to?(method_name, include_private=false)
+    @configuration.respond_to? method_name
+  end
 
-if defined?(ActiveRecord::Base)
-  ActiveRecord::Base.extend ActsAsTaggableOn::Taggable
-  ActiveRecord::Base.send :include, ActsAsTaggableOn::Tagger
+  def self.glue
+    setting = @configuration.delimiter
+    delimiter = setting.kind_of?(Array) ? setting[0] : setting
+    delimiter.ends_with?(' ') ? delimiter : "#{delimiter} "
+  end
+
+  class Configuration
+    attr_accessor :delimiter, :force_lowercase, :force_parameterize,
+      :strict_case_match, :remove_unused_tags
+
+    def initialize
+      @delimiter = ','
+      @force_lowercase = false
+      @force_parameterize = false
+      @strict_case_match = false
+      @remove_unused_tags = false
+    end
+  end
+
+  setup
 end
 
-if defined?(ActionView::Base)
-  ActionView::Base.send :include, TagsHelper
-end
+require 'acts_as_taggable_on/utils'
+
+require 'acts_as_taggable_on/taggable'
+require 'acts_as_taggable_on/acts_as_taggable_on/compatibility'
+require 'acts_as_taggable_on/acts_as_taggable_on/core'
+require 'acts_as_taggable_on/acts_as_taggable_on/collection'
+require 'acts_as_taggable_on/acts_as_taggable_on/cache'
+require 'acts_as_taggable_on/acts_as_taggable_on/ownership'
+require 'acts_as_taggable_on/acts_as_taggable_on/related'
+require 'acts_as_taggable_on/acts_as_taggable_on/dirty'
+
+require 'acts_as_taggable_on/tagger'
+require 'acts_as_taggable_on/tag'
+require 'acts_as_taggable_on/tag_list'
+require 'acts_as_taggable_on/tags_helper'
+require 'acts_as_taggable_on/tagging'
+require 'acts_as_taggable_on/engine'
+
+ActiveSupport.on_load(:active_record) do
+  extend ActsAsTaggableOn::Compatibility
+  extend ActsAsTaggableOn::Taggable
+  include ActsAsTaggableOn::Tagger
+end
+ActiveSupport.on_load(:action_view) do
+  include ActsAsTaggableOn::TagsHelper
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -1,53 +1,82 @@
 module ActsAsTaggableOn::Taggable
   module Cache
     def self.included(base)
-      # Skip adding caching capabilities if no cache columns exist
-      return unless base.tag_types.any? { |context| base.column_names.include?("cached_#{context.to_s.singularize}_list") }
-
-      base.send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
-      
-      base.class_eval do
-        before_save :save_cached_tag_list        
+      # When included, conditionally adds tag caching methods when the model
+      #   has any "cached_#{tag_type}_list" column
+      base.instance_eval do
+        # @private
+        def _has_tags_cache_columns?(db_columns)
+          db_column_names = db_columns.map(&:name)
+          tag_types.any? do |context|
+            db_column_names.include?("cached_#{context.to_s.singularize}_list")
+          end
+        end
+
+        # @private
+        def _add_tags_caching_methods
+          send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
+          extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
+
+          before_save :save_cached_tag_list
+
+          initialize_tags_cache
+        end
+
+        # ActiveRecord::Base.columns makes a database connection and caches the
+        #   calculated columns hash for the record as @columns.  Since we don't
+        #   want to add caching methods until we confirm the presence of a
+        #   caching column, and we don't want to force opening a database
+        #   connection when the class is loaded, here we intercept and cache
+        #   the call to :columns as @acts_as_taggable_on_cache_columns
+        #   to mimic the underlying behavior.  While processing this first
+        #   call to columns, we do the caching column check and dynamically add
+        #   the class and instance methods
+        #   FIXME: this method cannot compile in rubinius
+        def columns
+          @acts_as_taggable_on_cache_columns ||= begin
+            db_columns = super
+            _add_tags_caching_methods if _has_tags_cache_columns?(db_columns)
+            db_columns
+          end
+        end
+
       end
-      
-      base.intialize_acts_as_taggable_on_cache
     end
-    
+
     module ClassMethods
-      def intialize_acts_as_taggable_on_cache      
+      def initialize_tags_cache
         tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def self.caching_#{tag_type.singularize}_list?
               caching_tag_list_on?("#{tag_type}")
-            end        
-          )
-        end        
+            end
+          RUBY
+        end
       end
-      
+
       def acts_as_taggable_on(*args)
         super(*args)
-        intialize_acts_as_taggable_on_cache
+        initialize_tags_cache
       end
-      
+
       def caching_tag_list_on?(context)
         column_names.include?("cached_#{context.to_s.singularize}_list")
       end
     end
-    
-    module InstanceMethods      
+
+    module InstanceMethods
       def save_cached_tag_list
         tag_types.map(&:to_s).each do |tag_type|
           if self.class.send("caching_#{tag_type.singularize}_list?")
             if tag_list_cache_set_on(tag_type)
-              list = tag_list_cache_on(tag_type.singularize).to_a.flatten.compact.join(', ')
+              list = tag_list_cache_on(tag_type).to_a.flatten.compact.join(', ')
               self["cached_#{tag_type.singularize}_list"] = list
             end
           end
         end
-        
+
         true
       end
     end
   end
-end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -1,15 +1,14 @@
 module ActsAsTaggableOn::Taggable
   module Collection
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Collection::InstanceMethods
       base.extend ActsAsTaggableOn::Taggable::Collection::ClassMethods
       base.initialize_acts_as_taggable_on_collection
     end
-    
+
     module ClassMethods
       def initialize_acts_as_taggable_on_collection
         tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def self.#{tag_type.singularize}_counts(options={})
               tag_counts_on('#{tag_type}', options)
             end
@@ -19,25 +18,62 @@ module ActsAsTaggableOn::Taggable
             end
 
             def top_#{tag_type}(limit = 10)
-              tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
+              tag_counts_on('#{tag_type}', order: 'count desc', limit: limit.to_i)
             end
 
             def self.top_#{tag_type}(limit = 10)
-              tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
-            end        
-          )
-        end        
+              tag_counts_on('#{tag_type}', order: 'count desc', limit: limit.to_i)
+            end
+          RUBY
+        end
       end
-      
+
       def acts_as_taggable_on(*args)
         super(*args)
         initialize_acts_as_taggable_on_collection
       end
-      
+
       def tag_counts_on(context, options = {})
-        all_tag_counts(options.merge({:on => context.to_s}))
+        all_tag_counts(options.merge({on: context.to_s}))
+      end
+
+      def tags_on(context, options = {})
+        all_tags(options.merge({on: context.to_s}))
       end
-      
+
+      ##
+      # Calculate the tag names.
+      # To be used when you don't need tag counts and want to avoid the taggable joins.
+      #
+      # @param [Hash] options Options:
+      #                       * :start_at   - Restrict the tags to those created after a certain time
+      #                       * :end_at     - Restrict the tags to those created before a certain time
+      #                       * :conditions - A piece of SQL conditions to add to the query. Note we don't join the taggable objects for performance reasons.
+      #                       * :limit      - The maximum number of tags to return
+      #                       * :order      - A piece of SQL to order by. Eg 'tags.count desc' or 'taggings.created_at desc'
+      #                       * :on         - Scope the find to only include a certain context
+      def all_tags(options = {})
+        options.assert_valid_keys :start_at, :end_at, :conditions, :order, :limit, :on
+
+        ## Generate conditions:
+        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
+
+        ## Generate scope:
+        tagging_scope = ActsAsTaggableOn::Tagging.select("#{ActsAsTaggableOn::Tagging.table_name}.tag_id")
+        tag_scope = ActsAsTaggableOn::Tag.select("#{ActsAsTaggableOn::Tag.table_name}.*").order(options[:order]).limit(options[:limit])
+
+        # Joins and conditions
+        tagging_conditions(options).each { |condition| tagging_scope = tagging_scope.where(condition) }
+        tag_scope = tag_scope.where(options[:conditions])
+
+        group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
+
+        # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
+        tagging_scope = generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key).group(group_columns)
+
+        tag_scope_joins(tag_scope, tagging_scope)
+      end
+
       ##
       # Calculate the tag counts for all tags.
       #
@@ -53,46 +89,88 @@ 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]
-
-        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]
+        ## Generate conditions:
         options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
 
-        conditions = [
-          taggable_type,
-          taggable_id,
-          options[:conditions],
-          start_at,
-          end_at
-        ]
+        ## Generate joins:
+        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
+
+        ## Generate scope:
+        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
+        tagging_scope = tagging_scope.joins(taggable_join)
+        tagging_conditions(options).each { |condition| tagging_scope = tagging_scope.where(condition) }
+        tag_scope = tag_scope.where(options[:conditions])
+
+        # GROUP BY and HAVING clauses:
+        having = ["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) > 0"]
+        having.push sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) >= ?", options.delete(:at_least)]) if options[:at_least]
+        having.push sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) <= ?", options.delete(:at_most)]) if options[:at_most]
+        having = having.compact.join(' AND ')
+
+        group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
+
+        unless options[:id]
+          # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
+          tagging_scope = generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key)
+        end
+
+        tagging_scope = tagging_scope.group(group_columns).having(having)
+
+        tag_scope_joins(tag_scope, tagging_scope)
+      end
 
-        conditions = conditions.compact.join(' AND ')
+      def safe_to_sql(relation)
+        connection.respond_to?(:unprepared_statement) ? connection.unprepared_statement { relation.to_sql } : relation.to_sql
+      end
 
-        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"
+      private
 
-        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}'"
+      def generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key)
+        table_name_pkey = "#{table_name}.#{primary_key}"
+        if ActsAsTaggableOn::Utils.using_mysql?
+          # See https://github.com/mbleigh/acts-as-taggable-on/pull/457 for details
+          scoped_ids = select(table_name_pkey).map(&:id)
+          tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN (?)", scoped_ids)
+        else
+          tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{safe_to_sql(select(table_name_pkey))})")
         end
 
-        at_least  = sanitize_sql(['COUNT(*) >= ?', options.delete(:at_least)]) if options[:at_least]
-        at_most   = sanitize_sql(['COUNT(*) <= ?', options.delete(:at_most)]) if options[:at_most]
-        having    = [at_least, at_most].compact.join(' AND ')
-        group_by  = "#{grouped_column_names_for(Tag)} HAVING COUNT(*) > 0"
-        group_by << " AND #{having}" unless having.blank?
+        tagging_scope
+      end
+
+      def tagging_conditions(options)
+        tagging_conditions = []
+        tagging_conditions.push sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
+        tagging_conditions.push sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+
+        taggable_conditions = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.taggable_type = ?", base_class.name])
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = ?", options[:id]]) if options[:id]
+
+        tagging_conditions.push taggable_conditions
 
-        Tag.select("#{Tag.table_name}.*, COUNT(*) AS count").joins(joins.join(" ")).where(conditions).group(group_by).limit(options[:limit]).order(options[:order])
+        tagging_conditions
+      end
+
+      def tag_scope_joins(tag_scope, tagging_scope)
+        tag_scope = tag_scope.joins("JOIN (#{safe_to_sql(tagging_scope)}) AS #{ActsAsTaggableOn::Tagging.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id")
+        tag_scope.extending(CalculationMethods)
       end
     end
-    
-    module InstanceMethods
-      def tag_counts_on(context, options={})
-        self.class.tag_counts_on(context, options.merge(:id => id))
+
+    def tag_counts_on(context, options={})
+      self.class.tag_counts_on(context, options.merge(id: id))
+    end
+
+    module CalculationMethods
+      def count(column_name=:all)
+        # https://github.com/rails/rails/commit/da9b5d4a8435b744fcf278fffd6d7f1e36d4a4f2
+        super
       end
     end
   end
-end
+end