acts-as-taggable-on 3.1.0.rc1 → 3.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWU0YmVhNGFlMjYzYTg1NDdiNTRkODQ5ODViYjRmNGI3ZjNiMjZiZA==
+    MjM0ZjVlNjhmY2MyOWIwYTBkYzUwMTFiODc0YzQxMDYyNWEzNDA1Nw==
   data.tar.gz: !binary |-
-    YTQ0MDhmYzEyMDA5Yzc5MTQ5MjgxODY1NWQ4YzQ1ZGI1YmYwYTg1Ng==
+    NWYzMTZhOWNiYTEyZjcwNTBlMTIyYTcxMTVjZmRjMGEzMjgyZDljNw==
 SHA512:
   metadata.gz: !binary |-
-    OGU1OTU3ZjFkMDc1ZDAzNGY1YzI4Yzk1ODFlYTE1YWNjZThmMDcyYTBhMDMz
-    MzdiYWUxYjgxNDhiYzQ4ZmI5ZTgyMjIwMWZkYmI3ZTc2ZWM4YmUyNzUxZDYx
-    ZWJhNmU1ZDRiOWU2ZGZiM2YyMTAwMTc1YmZmYWYzYzdkMTg4YzY=
+    NThiZDVmYTFjZGFiMTFkNTM4Y2Y1M2Y1OGI1ZWM5N2U4YzVhZWMzMjJjMTZl
+    Y2ZlYzkwMjFlY2JlMDdkYzk3YmNmYjNhNDAzZDFjMDhkYmQxZGQ4MGJhM2Vi
+    Mzg4MWMyNDNkZmVkNWMwYmI1ZDBkZDQxMzgyNWQzMTI2NTYwNmY=
   data.tar.gz: !binary |-
-    YjU3MzdjMTIyNDM2ZDY2ZmNhZjUxZDhlMTgwYTM3NjFiY2E2Mzg5NDRmZDNi
-    ZTU1NTQ1MjAwMzIwNDVjNzEyYmNlZTU1MmNkYTk3OGY2ZjhkNTA2M2M2ZWVj
-    ZDQzODA0OTMxMTMxNDMzNTY5ZTk3NWE1MzgxZDM3ZjgwMDBjMTA=
+    OWZkOTMxM2ZiODMyYWQyOTBkN2MyMDQ5NmMzYTJlNjUyOWJkMzliZjFkZDg1
+    YjU5M2M4Y2NmOWZhZDcxODUzODRjNzc2YjE0NWQ2ZjVkMDhjNWY1NGE2MzQy
+    OWVmZTVkZWU2OTljNzMwZmVmZDY5YTkxMjY5YzRiOGZhZDgxOWM=

data/.travis.yml

@@ -2,6 +2,7 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.0
+  - 2.1.1
 env:
   - DB=sqlite3
   - DB=mysql
@@ -10,6 +11,7 @@ gemfile:
   - gemfiles/rails_3.2.gemfile
   - gemfiles/rails_4.0.gemfile
   - gemfiles/rails_4.1.gemfile
+  - gemfiles/rails_edge.gemfile
 cache: bundler
 script: bundle exec rake
 before_install:

data/Appraisals

@@ -9,3 +9,7 @@ end
 appraise "rails-4.1" do
   gem "rails", "~> 4.1.0.beta1"
 end
+
+appraise "rails-edge" do
+  gem "rails", github: "rails/rails"
+end

data/CHANGELOG.md

@@ -4,13 +4,25 @@ Each change should fall into categories that would affect whether the release is
 
 As such, a _Feature_ would map to either major or minor. A _bug fix_ to a patch.  And _misc_ is either minor or patch, the difference being kind of fuzzy for the purposes of history.  Adding tests would be patch level.
 
-### Master [changes](https://github.com/mbleigh/acts-as-taggable-on/compare/v3.0.1...master)
+### Master [changes](https://github.com/mbleigh/acts-as-taggable-on/compare/v3.1.0...master)
 
 * Breaking Changes
 * Features
 * Fixes
+* Performance
 * Misc
 
+### [3.1.0 / 2014-03-31](https://github.com/mbleigh/acts-as-taggable-on/compare/v3.0.1...v3.1.0)
+
+* Fixes
+  * [@mikehale #487 Match_all respects context](https://github.com/mbleigh/acts-as-taggable-on/pull/487)
+* Performance
+  * [@dgilperez #390 Add taggings counter cache](https://github.com/mbleigh/acts-as-taggable-on/pull/390)
+* Misc
+ * [@jonseaberg Add missing indexes to schema used in specs #474](https://github.com/mbleigh/acts-as-taggable-on/pull/474)
+ * [@seuros Specify Ruby >= 1.9.3 required in gemspec](https://github.com/mbleigh/acts-as-taggable-on/pull/502)
+ * [@kiasaki Add missing quotes to code example](https://github.com/mbleigh/acts-as-taggable-on/pull/501)
+
 ### [3.1.0.rc1 / 2014-02-26](https://github.com/mbleigh/acts-as-taggable-on/compare/v3.0.1...v3.1.0.rc1)
 
 * Features
@@ -22,6 +34,7 @@ As such, a _Feature_ would map to either major or minor. A _bug fix_ to a patch.
   * [@rgould #417 Let '.count' work when tagged_with is accompanied by a group clause](https://github.com/mbleigh/acts-as-taggable-on/pull/417)
   * [@developer88 #461 Move 'Distinct' out of select string and use .uniq instead](https://github.com/mbleigh/acts-as-taggable-on/pull/461)
   * [@gerard-leijdekkers #473 Fixed down migration index name](https://github.com/mbleigh/acts-as-taggable-on/pull/473)
+  * [@leo-souza #498 Use database's lower function for case-insensitive match](https://github.com/mbleigh/acts-as-taggable-on/pull/498)
 * Misc
   * [@billychan #463 Thread safe support](https://github.com/mbleigh/acts-as-taggable-on/pull/463)
   * [@billychan #386 Add parse:true instructions to README](https://github.com/mbleigh/acts-as-taggable-on/pull/386)

data/CONTRIBUTING.md

@@ -11,7 +11,7 @@
 2. Install the gem dependencies: `bundle install`
 3. Make the changes you want and back them up with tests.
   * [Run the tests](https://github.com/mbleigh/acts-as-taggable-on#testing) (`bundle exec rake spec`)
-4. Update the CHAGELOG.md file with your changes and give yourself credit
+4. Update the CHANGELOG.md file with your changes and give yourself credit
 5. Commit and create a pull request with details as to what has been changed and why
   * Use well-described, small (atomic) commits.
   * Include links to any relevant github issues.

data/README.md

@@ -1,6 +1,7 @@
 # ActsAsTaggableOn
 [![Build Status](https://secure.travis-ci.org/mbleigh/acts-as-taggable-on.png)](http://travis-ci.org/mbleigh/acts-as-taggable-on)
 [![Code Climate](https://codeclimate.com/github/mbleigh/acts-as-taggable-on.png)](https://codeclimate.com/github/mbleigh/acts-as-taggable-on)
+[![Inline docs](http://inch-pages.github.io/github/mbleigh/acts-as-taggable-on.png)](http://inch-pages.github.io/github/mbleigh/acts-as-taggable-on)
 
 This plugin was originally based on Acts as Taggable on Steroids by Jonathan Viney.
 It has evolved substantially since that point, but all credit goes to him for the
@@ -175,7 +176,7 @@ User.tagged_with(["awesome", "cool"], :any => true)
 User.tagged_with(["awesome", "cool"], :exclude => 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)
+User.tagged_with(['awesome', 'cool'], :on => :tags, :any => true).tagged_with(['smart', 'shy'], :on => :skills, :any => true)
 ```
 
 You can also use `:wild => true` option along with `:any` or `:exclude` option. It will looking for `%awesome%` and `%cool%` in sql.
@@ -339,6 +340,8 @@ If you want to change the default delimiter (it defaults to ','). You can also p
 ActsAsTaggableOn.delimiter = ','
 ```
 
+*NOTE: SQLite by default can't upcase or downcase multibyte characters, resulting in unwanted behavior. Load the SQLite ICU extension for proper handle of such characters. [See docs](http://www.sqlite.org/src/artifact?ci=trunk&filename=ext/icu/README.txt)*
+
 ## Contributors
 
 We have a long list of valued contributors. [Check them all](https://github.com/mbleigh/acts-as-taggable-on/contributors)

data/Rakefile

@@ -5,6 +5,9 @@ rescue LoadError
   STDERR.puts "Bundler not loaded"
 end
 
+desc 'Default: run specs'
+task :default => :spec
+
 desc 'Copy sample spec database.yml over if not exists'
 task :copy_db_config do
   cp 'spec/database.yml.sample', 'spec/database.yml'
@@ -12,9 +15,6 @@ end
 
 task :spec => [:copy_db_config]
 
-desc 'Default: run specs'
-task :default => :spec
-
 begin
   require 'appraisal'
   desc 'Run tests across gemfiles specified in Appraisals'

data/acts-as-taggable-on.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+  gem.required_ruby_version     = '>= 1.9.3'
 
   if File.exists?('UPGRADING.md')
     gem.post_install_message = File.read('UPGRADING.md')

data/db/migrate/3_add_taggings_counter_cache_to_tags.rb

@@ -0,0 +1,13 @@
+class AddTaggingsCounterCacheToTags < ActiveRecord::Migration
+  def self.up
+    add_column :tags, :taggings_count, :integer, :default => 0
+
+    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/rails_edge.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", :github=>"rails/rails"
+
+gemspec :path=>"../"

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -22,15 +22,17 @@ module ActsAsTaggableOn::Taggable
           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_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
+        # 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
         def columns
-          @acts_as_taggable_on_columns ||= begin
+          @acts_as_taggable_on_cache_columns ||= begin
             db_columns = super
             if _has_tags_cache_columns?(db_columns)
               _add_tags_caching_methods

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -58,29 +58,13 @@ 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}.context = ?", options.delete(:on).to_s]) if options[:on]
-
-        tagging_conditions = [
-          taggable_conditions,
-          start_at_conditions,
-          end_at_conditions
-        ].compact.reverse
-
-        tag_conditions = [
-          options[:conditions]
-        ].compact.reverse
-
         ## 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.each { |condition| tagging_scope = tagging_scope.where(condition) }
-        tag_conditions.each     { |condition| tag_scope     = tag_scope.where(condition)     }
+        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"
 
@@ -88,10 +72,10 @@ module ActsAsTaggableOn::Taggable
         scoped_select = "#{table_name}.#{primary_key}"
         tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{safe_to_sql(select(scoped_select))})").group(group_columns)
 
-        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)
+        tag_scope_joins(tag_scope, tagging_scope)
       end
 
+
       ##
       # Calculate the tag counts for all tags.
       #
@@ -107,56 +91,28 @@ 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
 
-        scope = {}
-
         ## 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[: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,
-          scope[:conditions],
-          start_at_conditions,
-          end_at_conditions
-        ].compact.reverse
-
-        tag_conditions = [
-          options[:conditions]
-        ].compact.reverse
-
         ## 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
 
-        tagging_joins = [
-          taggable_join,
-          scope[:joins]
-        ].compact
-
-        tag_joins = [
-        ].compact
 
         ## 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_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)     }
+        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:
-        at_least  = sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) >= ?", options.delete(:at_least)]) if options[:at_least]
-        at_most   = sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) <= ?", options.delete(:at_most)]) if options[:at_most]
-        having    = ["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) > 0", at_least, at_most].compact.join(' AND ')
+        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"
 
@@ -168,13 +124,33 @@ module ActsAsTaggableOn::Taggable
 
         tagging_scope = tagging_scope.group(group_columns).having(having)
 
-        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)
+        tag_scope_joins(tag_scope, tagging_scope)
       end
 
       def safe_to_sql(relation)
         connection.respond_to?(:unprepared_statement) ? connection.unprepared_statement{relation.to_sql} : relation.to_sql
       end
+
+      private
+
+      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
+
+        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
 
     def tag_counts_on(context, options={})

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -193,6 +193,8 @@ module ActsAsTaggableOn::Taggable
                    "  ON #{taggings_alias}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
                    " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name, nil)}"
 
+          joins << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+
           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}"

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -37,33 +37,19 @@ module ActsAsTaggableOn::Taggable
 
     def matching_contexts_for(search_context, result_context, klass, options = {})
       tags_to_find = tags_on(search_context).collect { |t| t.name }
-
-      klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count").
-            from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}").
-            where(["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context]).
-            group(group_columns(klass)).
-            order("count DESC")
+      related_where(klass, ["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context])
     end
 
     def related_tags_for(context, klass, options = {})
       tags_to_ignore = Array.wrap(options.delete(:ignore)).map(&:to_s) || []
       tags_to_find = tags_on(context).collect { |t| t.name }.reject { |t| tags_to_ignore.include? t }
-
-      klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count").
-            from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}").
-            where(["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?)", tags_to_find]).
-            group(group_columns(klass)).
-            order("count DESC")
+      related_where(klass, ["#{exclude_self(klass, id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?)", tags_to_find])
     end
 
     private
 
     def exclude_self(klass, id)
-      if [self.class.base_class, self.class].include? klass
-        "#{klass.table_name}.#{klass.primary_key} != #{id} AND"
-      else
-        nil
-      end
+        "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
     end
 
     def group_columns(klass)
@@ -73,5 +59,13 @@ module ActsAsTaggableOn::Taggable
         "#{klass.table_name}.#{klass.primary_key}"
       end
     end
+
+    def related_where(klass, conditions)
+      klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count").
+          from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}").
+          group(group_columns(klass)).
+          order("count DESC").
+          where(conditions)
+    end
   end
 end

data/lib/acts_as_taggable_on/tag.rb

@@ -24,9 +24,9 @@ module ActsAsTaggableOn
 
     def self.named(name)
       if ActsAsTaggableOn.strict_case_match
-        where(["name = #{binary}?", name])
+        where(["name = #{binary}?", as_8bit_ascii(name)])
       else
-        where(["lower(name) = ?", name.downcase])
+        where(["LOWER(name) = LOWER(?)", as_8bit_ascii(unicode_downcase(name))])
       end
     end
 
@@ -38,8 +38,7 @@ module ActsAsTaggableOn
         where(clause)
       else
         clause = list.map { |tag|
-          lowercase_ascii_tag = as_8bit_ascii(tag).downcase
-          sanitize_sql(["lower(name) = ?", lowercase_ascii_tag])
+          sanitize_sql(["LOWER(name) = LOWER(?)", as_8bit_ascii(unicode_downcase(tag))])
         }.join(" OR ")
         where(clause)
       end
@@ -101,14 +100,22 @@ module ActsAsTaggableOn
 
       def comparable_name(str)
         if ActsAsTaggableOn.strict_case_match
-          as_8bit_ascii(str)
+          str
         else
-          as_8bit_ascii(str).downcase
+          unicode_downcase(str.to_s)
         end
       end
 
       def binary
-        /mysql/ === ActiveRecord::Base.connection_config[:adapter] ? "BINARY " : nil
+        using_mysql? ? "BINARY " : nil
+      end
+
+      def unicode_downcase(string)
+        if ActiveSupport::Multibyte::Unicode.respond_to?(:downcase)
+          ActiveSupport::Multibyte::Unicode.downcase(string)
+        else
+          ActiveSupport::Multibyte::Chars.new(string).downcase.to_s  
+        end
       end
 
       def as_8bit_ascii(string)

data/lib/acts_as_taggable_on/tagging.rb

@@ -9,7 +9,6 @@ module ActsAsTaggableOn
                     :tagger,
                     :tagger_type,
                     :tagger_id if defined?(ActiveModel::MassAssignmentSecurity)
-
     belongs_to :tag, :class_name => 'ActsAsTaggableOn::Tag'
     belongs_to :taggable, :polymorphic => true
     belongs_to :tagger,   :polymorphic => true
@@ -17,14 +16,29 @@ module ActsAsTaggableOn
     validates_presence_of :context
     validates_presence_of :tag_id
 
-    validates_uniqueness_of :tag_id, :scope => [ :taggable_type, :taggable_id, :context, :tagger_id, :tagger_type ]
+    validates_uniqueness_of :tag_id, :scope => [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
 
     after_destroy :remove_unused_tags
 
+    # Conditionally adds a counter cache when cache column is present.
+    #  We just regenerate the association. It's the easiest way.
+    # TODO: require the counter cache in release 4.0.0 and remove these methods
+    # @see :columns in ActsAsTaggableOn::Taggable::Cache
+    def self.columns
+      @acts_as_taggable_on_counter_columns ||= begin
+        db_columns = super
+        belongs_to :tag, :class_name => 'ActsAsTaggableOn::Tag', :counter_cache => ActsAsTaggableOn::Tag.column_names.include?('taggings_count')
+        db_columns
+      end
+    end
+
+
+
     private
 
     def remove_unused_tags
       if ActsAsTaggableOn.remove_unused_tags
+        # TODO: use taggings_count in release 4.0.0
         if tag.taggings.count.zero?
           tag.destroy
         end

data/lib/acts_as_taggable_on/utils.rb

@@ -1,11 +1,25 @@
 module ActsAsTaggableOn
   module Utils
+
+    def connection
+      ::ActiveRecord::Base.connection
+    end
+
     def using_postgresql?
-      ::ActiveRecord::Base.connection && ::ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+      connection && connection.adapter_name == 'PostgreSQL'
     end
 
     def using_sqlite?
-      ::ActiveRecord::Base.connection && ::ActiveRecord::Base.connection.adapter_name == 'SQLite'
+      connection && connection.adapter_name == 'SQLite'
+    end
+
+    def using_mysql?
+      #We should probably use regex for mysql to support prehistoric adapters
+      connection && connection.adapter_name == 'Mysql2'
+    end
+
+    def using_case_insensitive_collation?
+      using_mysql? && ::ActiveRecord::Base.connection.collation =~ /_ci\Z/
     end
 
     def sha_prefix(string)
@@ -20,7 +34,7 @@ module ActsAsTaggableOn
 
     # escape _ and % characters in strings, since these are wildcards in SQL.
     def escape_like(str)
-      str.gsub(/[!%_]/){ |x| '!' + x }
+      str.gsub(/[!%_]/) { |x| '!' + x }
     end
   end
 end

data/lib/acts_as_taggable_on/version.rb

@@ -1,4 +1,4 @@
 module ActsAsTaggableOn
-  VERSION = '3.1.0.rc1'
+  VERSION = '3.1.0'
 end
 

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -1,5 +1,11 @@
 # encoding: utf-8
 require 'spec_helper'
+require 'db/migrate/2_add_missing_unique_indices.rb'
+
+shared_examples_for 'without unique index' do
+  before { AddMissingUniqueIndices.down }
+  after { ActsAsTaggableOn::Tag.delete_all; AddMissingUniqueIndices.up }
+end
 
 describe ActsAsTaggableOn::Tag do
   before(:each) do
@@ -9,14 +15,33 @@ describe ActsAsTaggableOn::Tag do
   end
 
   describe "named like any" do
-    before(:each) do
-      ActsAsTaggableOn::Tag.create(:name => "Awesome")
-      ActsAsTaggableOn::Tag.create(:name => "awesome")
-      ActsAsTaggableOn::Tag.create(:name => "epic")
+    context "case insensitive collation and unique index on tag name" do
+      if described_class.using_case_insensitive_collation?
+        before(:each) do
+          ActsAsTaggableOn::Tag.create(:name => "Awesome")
+          ActsAsTaggableOn::Tag.create(:name => "epic")
+        end
+
+        it "should find both tags" do
+          ActsAsTaggableOn::Tag.named_like_any(["awesome", "epic"]).should have(2).items
+        end
+      end
     end
 
-    it "should find both tags" do
-      ActsAsTaggableOn::Tag.named_like_any(["awesome", "epic"]).should have(3).items
+    context "case insensitive collation without indexes or case sensitive collation with indexes" do
+      if described_class.using_case_insensitive_collation?
+        include_context 'without unique index'
+      end
+
+      before(:each) do
+        ActsAsTaggableOn::Tag.create(:name => "Awesome")
+        ActsAsTaggableOn::Tag.create(:name => "awesome")
+        ActsAsTaggableOn::Tag.create(:name => "epic")
+      end
+
+      it "should find both tags" do
+        ActsAsTaggableOn::Tag.named_like_any(["awesome", "epic"]).should have(3).items
+      end
     end
   end
 
@@ -72,11 +97,17 @@ describe ActsAsTaggableOn::Tag do
       ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("AWESOME").should == [@tag]
     end
 
-    it "should find by name case sensitive" do
-      ActsAsTaggableOn.strict_case_match = true
-      expect {
-        ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("AWESOME")
-      }.to change(ActsAsTaggableOn::Tag, :count).by(1)  
+    context "case sensitive" do
+      if described_class.using_case_insensitive_collation?
+        include_context 'without unique index'
+      end
+
+      it "should find by name case sensitive" do
+        ActsAsTaggableOn.strict_case_match = true
+        expect {
+          ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("AWESOME")
+        }.to change(ActsAsTaggableOn::Tag, :count).by(1)
+      end
     end
 
     it "should create by name" do
@@ -85,11 +116,17 @@ describe ActsAsTaggableOn::Tag do
       }.to change(ActsAsTaggableOn::Tag, :count).by(1)
     end
 
-    it "should find or create by name case sensitive" do
-      ActsAsTaggableOn.strict_case_match = true
-      expect {
-        ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("AWESOME", 'awesome').map(&:name).should == ["AWESOME", "awesome"]
-      }.to change(ActsAsTaggableOn::Tag, :count).by(1)
+    context "case sensitive" do
+      if described_class.using_case_insensitive_collation?
+        include_context 'without unique index'
+      end
+
+      it "should find or create by name case sensitive" do
+        ActsAsTaggableOn.strict_case_match = true
+        expect {
+          ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("AWESOME", 'awesome').map(&:name).should == ["AWESOME", "awesome"]
+        }.to change(ActsAsTaggableOn::Tag, :count).by(1)
+      end
     end
 
     it "should find or create by name" do
@@ -178,21 +215,33 @@ describe ActsAsTaggableOn::Tag do
       ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("awesome").should == @tag
     end
 
-    it "should find by name case sensitively" do
-      expect {
-        ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("AWESOME")
-      }.to change(ActsAsTaggableOn::Tag, :count)
+    context "case sensitive" do
+      if described_class.using_case_insensitive_collation?
+        include_context 'without unique index'
+      end
 
-      ActsAsTaggableOn::Tag.last.name.should == "AWESOME"
+      it "should find by name case sensitively" do
+        expect {
+          ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("AWESOME")
+        }.to change(ActsAsTaggableOn::Tag, :count)
+
+        ActsAsTaggableOn::Tag.last.name.should == "AWESOME"
+      end
     end
 
-    it "should have a named_scope named(something) that matches exactly" do
-      uppercase_tag = ActsAsTaggableOn::Tag.create(:name => "Cool")
-      @tag.name     = "cool"
-      @tag.save!
+    context "case sensitive" do
+      if described_class.using_case_insensitive_collation?
+        include_context 'without unique index'
+      end
 
-      ActsAsTaggableOn::Tag.named('cool').should include(@tag)
-      ActsAsTaggableOn::Tag.named('cool').should_not include(uppercase_tag)
+      it "should have a named_scope named(something) that matches exactly" do
+        uppercase_tag = ActsAsTaggableOn::Tag.create(:name => "Cool")
+        @tag.name     = "cool"
+        @tag.save!
+
+        ActsAsTaggableOn::Tag.named('cool').should include(@tag)
+        ActsAsTaggableOn::Tag.named('cool').should_not include(uppercase_tag)
+      end
     end
 
     it "should not change enconding" do
@@ -209,16 +258,17 @@ describe ActsAsTaggableOn::Tag do
     before { ActsAsTaggableOn::Tag.create(:name => 'ror') }
 
     context "when don't need unique names" do
+      include_context 'without unique index'
       it "should not run uniqueness validation" do
         duplicate_tag.stub(:validates_name_uniqueness?).and_return(false)
         duplicate_tag.save
         duplicate_tag.should be_persisted
-      end  
+      end
     end
 
     context "when do need unique names" do
       it "should run uniqueness validation" do
-        duplicate_tag.should_not be_valid        
+        duplicate_tag.should_not be_valid
       end
 
       it "add error to name" do

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 
 describe "Taggable To Preserve Order" do
@@ -242,6 +243,34 @@ describe "Taggable" do
     TaggableModel.tagged_with("ruby").to_a.should == TaggableModel.tagged_with("Ruby").to_a
   end
 
+  unless ActsAsTaggableOn::Tag.using_sqlite?
+    it "should not care about case for unicode names" do
+      ActsAsTaggableOn.strict_case_match = false
+  
+      anya = TaggableModel.create(:name => "Anya", :tag_list => "ПРИВЕТ")
+      igor = TaggableModel.create(:name => "Igor", :tag_list => "привет")
+      katia = TaggableModel.create(:name => "Katia", :tag_list => "ПРИВЕТ")
+
+      ActsAsTaggableOn::Tag.all.size.should == 1
+      TaggableModel.tagged_with("привет").to_a.should == TaggableModel.tagged_with("ПРИВЕТ").to_a
+    end
+  end
+
+  it "should be able to create and find tags in languages without capitalization" do
+    ActsAsTaggableOn.strict_case_match = false
+    chihiro = TaggableModel.create(:name => "Chihiro", :tag_list => "日本の")
+    salim = TaggableModel.create(:name => "Salim", :tag_list => "עברית")
+    ieie = TaggableModel.create(:name => "Ieie", :tag_list => "中国的")
+    yasser = TaggableModel.create(:name => "Yasser", :tag_list => "العربية")
+    emo = TaggableModel.create(:name => "Emo", :tag_list => "✏")
+
+    TaggableModel.tagged_with("日本の").to_a.size.should == 1
+    TaggableModel.tagged_with("עברית").to_a.size.should == 1
+    TaggableModel.tagged_with("中国的").to_a.size.should == 1
+    TaggableModel.tagged_with("العربية").to_a.size.should == 1
+    TaggableModel.tagged_with("✏").to_a.size.should == 1
+  end 
+
   it "should be able to get tag counts on model as a whole" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
@@ -430,6 +459,14 @@ describe "Taggable" do
     TaggableModel.tagged_with("fitter, happier", :match_all => true).to_a.should == [steve]
   end
 
+  it "should be able to find tagged with only the matching tags for a context" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "lazy, happier", :skill_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "fitter, happier, inefficient", :skill_list => "css")
+    steve = TaggableModel.create(:name => 'Steve', :tag_list => "fitter, happier", :skill_list => "ruby, rails, css")
+
+    TaggableModel.tagged_with("css", :on => :skills, :match_all => true).to_a.should == [frank]
+  end
+
   it "should be able to find tagged with some excluded tags" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "happier, lazy")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "happier")
@@ -468,7 +505,7 @@ describe "Taggable" do
 
   describe "grouped_column_names_for method" do
     it "should return all column names joined for Tag GROUP clause" do
-      @taggable.grouped_column_names_for(ActsAsTaggableOn::Tag).should == "tags.id, tags.name"
+      @taggable.grouped_column_names_for(ActsAsTaggableOn::Tag).should == "tags.id, tags.name, tags.taggings_count"
     end
 
     it "should return all column names joined for TaggableModel GROUP clause" do
@@ -654,5 +691,3 @@ describe "Taggable" do
     end
   end
 end
-
-

data/spec/schema.rb

@@ -1,7 +1,9 @@
 ActiveRecord::Schema.define :version => 0 do
   create_table :tags, :force => true do |t|
     t.string :name
+    t.integer :taggings_count, :default => 0
   end
+  add_index "tags", ["name"], name: "index_tags_on_name", unique: true
 
   create_table :taggings, :force => true do |t|
     t.references :tag
@@ -17,6 +19,10 @@ ActiveRecord::Schema.define :version => 0 do
 
     t.datetime :created_at
   end
+  add_index "taggings",
+            ["tag_id", "taggable_id", "taggable_type", "context", "tagger_id", "tagger_type"],
+            unique: true, name: "taggings_idx"
+
   # above copied from
   # generators/acts_as_taggable_on/migration/migration_generator
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts-as-taggable-on
 version: !ruby/object:Gem::Version
-  version: 3.1.0.rc1
+  version: 3.1.0
 platform: ruby
 authors:
 - Michael Bleigh
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-27 00:00:00.000000000 Z
+date: 2014-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -179,9 +179,11 @@ files:
 - acts-as-taggable-on.gemspec
 - db/migrate/1_acts_as_taggable_on_migration.rb
 - db/migrate/2_add_missing_unique_indices.rb
+- db/migrate/3_add_taggings_counter_cache_to_tags.rb
 - gemfiles/rails_3.2.gemfile
 - gemfiles/rails_4.0.gemfile
 - gemfiles/rails_4.1.gemfile
+- gemfiles/rails_edge.gemfile
 - lib/acts-as-taggable-on.rb
 - lib/acts_as_taggable_on.rb
 - lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb
@@ -231,15 +233,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Advanced tagging for Rails.