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

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OGMwZTUwZGZkYzg3ZGRhM2E3ZWNhYjU1MjE4OGFhYjU5MTk2NTAwMg==
+    NWU0YmVhNGFlMjYzYTg1NDdiNTRkODQ5ODViYjRmNGI3ZjNiMjZiZA==
   data.tar.gz: !binary |-
-    MmE0ZDlhNmE2ZjRjY2RiNGU3YjVlMzE1MGQwMjVhMzhhZDA5ZmYzMQ==
+    YTQ0MDhmYzEyMDA5Yzc5MTQ5MjgxODY1NWQ4YzQ1ZGI1YmYwYTg1Ng==
 SHA512:
   metadata.gz: !binary |-
-    YmI2YTcwNGFhMWFhN2U4YmQ1NjYwNzE0NjY0Nzc4MDZjN2E5NGY1ZjJlZDkz
-    OWExZTIxNTkzYWM2ZTAwNjE2ZDRmMzk1NDc3NDU1ZTU2ZGIzZThkNWNhZGQy
-    ODJlNWM0MThiNjFkYmY3NTRiNTYxYzU5ZmQxYmU3Mjc4MWYxNjM=
+    OGU1OTU3ZjFkMDc1ZDAzNGY1YzI4Yzk1ODFlYTE1YWNjZThmMDcyYTBhMDMz
+    MzdiYWUxYjgxNDhiYzQ4ZmI5ZTgyMjIwMWZkYmI3ZTc2ZWM4YmUyNzUxZDYx
+    ZWJhNmU1ZDRiOWU2ZGZiM2YyMTAwMTc1YmZmYWYzYzdkMTg4YzY=
   data.tar.gz: !binary |-
-    ZTE4ZGVmYTZlMTlkMWE1OTY5OGQxYTE5ZmNmYWE3NDJhNTZmZjcyZTEyMzI1
-    OGU1YTFiOTNhNTliZTliYjhmMzcwMDg4ZTBjY2M0MjcwZTYxMzg4NTY4OGQw
-    MDU0ZmNlOTlhODkyOTk4NmYyNGJhZGM1NDIyZTQ1MzkxMmJiNWE=
+    YjU3MzdjMTIyNDM2ZDY2ZmNhZjUxZDhlMTgwYTM3NjFiY2E2Mzg5NDRmZDNi
+    ZTU1NTQ1MjAwMzIwNDVjNzEyYmNlZTU1MmNkYTk3OGY2ZjhkNTA2M2M2ZWVj
+    ZDQzODA0OTMxMTMxNDMzNTY5ZTk3NWE1MzgxZDM3ZjgwMDBjMTA=

data/CHANGELOG.md

@@ -4,25 +4,32 @@ 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.2...master)
+### Master [changes](https://github.com/mbleigh/acts-as-taggable-on/compare/v3.0.1...master)
 
 * Breaking Changes
 * Features
+* Fixes
+* Misc
+
+### [3.1.0.rc1 / 2014-02-26](https://github.com/mbleigh/acts-as-taggable-on/compare/v3.0.1...v3.1.0.rc1)
+
+* Features
+  * [@jamesburke-examtime #467 Add :order_by_matching_tag_count option](https://github.com/mbleigh/acts-as-taggable-on/pull/469)
 * Fixes
   * [@rafael #406 Dirty attributes not correctly derived](https://github.com/mbleigh/acts-as-taggable-on/pull/406)
   * [@bzbnhang #440 Did not respect strict_case_match](https://github.com/mbleigh/acts-as-taggable-on/pull/440)
   * [@znz #456 Fix breaking encoding of tag](https://github.com/mbleigh/acts-as-taggable-on/pull/456)
+  * [@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)
 * 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)
   * [@seuros #449 Improve README/UPGRADING/post install docs](https://github.com/mbleigh/acts-as-taggable-on/pull/449)
   * [@seuros #452 Remove I18n deprecation warning in specs](https://github.com/mbleigh/acts-as-taggable-on/pull/452)
   * [@seuros #453 Test against Ruby 2.1 on Travis CI](https://github.com/mbleigh/acts-as-taggable-on/pull/453)
   * [@takashi #454 Clarify example in docs](https://github.com/mbleigh/acts-as-taggable-on/pull/454)
 
-### [3.0.2 / 2014-03-12](https://github.com/mbleigh/acts-as-taggable-on/compare/v3.0.1...v3.0.2)
-
-* [@mikehale #486 Match_all respects context. Backport of #487](https://github.com/mbleigh/acts-as-taggable-on/pull/486)
-
 ### [3.0.1 / 2014-01-08](https://github.com/mbleigh/acts-as-taggable-on/compare/v3.0.0...v3.0.1)
 
 * Fixes

data/acts-as-taggable-on.gemspec

@@ -22,7 +22,9 @@ Gem::Specification.new do |gem|
     gem.post_install_message = File.read('UPGRADING.md')
   end
 
-  gem.add_runtime_dependency 'rails', ['>= 3', '< 5']
+  gem.add_runtime_dependency 'activerecord',  ['>= 3', '< 5']
+  gem.add_runtime_dependency 'activesupport', ['>= 3', '< 5']
+  gem.add_runtime_dependency 'actionpack',    ['>= 3', '< 5']
 
   gem.add_development_dependency 'sqlite3'
   gem.add_development_dependency 'mysql2', '~> 0.3.7'

data/db/migrate/2_add_missing_unique_indices.rb

@@ -13,7 +13,7 @@ class AddMissingUniqueIndices < ActiveRecord::Migration
   def self.down
     remove_index :tags, :name
 
-    remove_index :taggings, name: 'tagging_idx'
+    remove_index :taggings, name: 'taggings_idx'
     add_index :taggings, :tag_id
     add_index :taggings, [:taggable_id, :taggable_type, :context]
   end

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

@@ -2,34 +2,44 @@ require "active_record"
 require "active_record/version"
 require "active_support/core_ext/module"
 require "action_view"
-require 'active_support/all'
 
 require "digest/sha1"
 
 module ActsAsTaggableOn
-  mattr_accessor :delimiter
-  @@delimiter = ','
-
-  mattr_accessor :force_lowercase
-  @@force_lowercase = false
-
-  mattr_accessor :force_parameterize
-  @@force_parameterize = false
+  def self.setup
+    @configuration ||= Configuration.new
+    yield @configuration if block_given?
+  end
 
-  mattr_accessor :strict_case_match
-  @@strict_case_match = false
+  def self.method_missing(method_name, *args, &block)
+    @configuration.respond_to?(method_name) ?
+      @configuration.send(method_name, *args, &block) : super
+  end
 
-  mattr_accessor :remove_unused_tags
-  self.remove_unused_tags = false
+  def self.respond_to?(method_name, include_private=false)
+    @configuration.respond_to? method_name
+  end
 
   def self.glue
-    delimiter = @@delimiter.kind_of?(Array) ? @@delimiter[0] : @@delimiter
+    setting = @configuration.delimiter
+    delimiter = setting.kind_of?(Array) ? setting[0] : setting
     delimiter.ends_with?(" ") ? delimiter : "#{delimiter} "
   end
 
-  def self.setup
-    yield self
+  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
 
 

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -7,9 +7,9 @@ module ActsAsTaggableOn::Taggable
         # @private
         def _has_tags_cache_columns?(db_columns)
           db_column_names = db_columns.map(&:name)
-          tag_types.any? {|context|
+          tag_types.any? do |context|
             db_column_names.include?("cached_#{context.to_s.singularize}_list")
-          }
+          end
         end
 
         # @private

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -1,7 +1,6 @@
 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
@@ -178,10 +177,8 @@ module ActsAsTaggableOn::Taggable
       end
     end
 
-    module InstanceMethods
-      def tag_counts_on(context, options={})
-        self.class.tag_counts_on(context, options.merge(:id => id))
-      end
+    def tag_counts_on(context, options={})
+      self.class.tag_counts_on(context, options.merge(:id => id))
     end
 
     module CalculationMethods

data/lib/acts_as_taggable_on/acts_as_taggable_on/compatibility.rb

@@ -12,7 +12,7 @@ module ActsAsTaggableOn::Compatibility
     scope_opts, opts = parse_options(opts)
 
     unless scope_opts.empty?
-      scope = lambda do 
+      scope = lambda do
         scope_opts.inject(self) { |result, hash| result.send *hash }
       end
     end

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -1,7 +1,6 @@
 module ActsAsTaggableOn::Taggable
   module Core
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Core::InstanceMethods
       base.extend ActsAsTaggableOn::Taggable::Core::ClassMethods
 
       base.class_eval do
@@ -72,6 +71,7 @@ module ActsAsTaggableOn::Taggable
       # @param [Hash] options A hash of options to alter you query:
       #                       * <tt>:exclude</tt> - if set to true, return objects that are *NOT* tagged with the specified tags
       #                       * <tt>:any</tt> - if set to true, return objects that are tagged with *ANY* of the specified tags
+      #                       * <tt>:order_by_matching_tag_count</tt> - if set to true and used with :any, sort by objects matching the most tags, descending
       #                       * <tt>:match_all</tt> - if set to true, return objects that are *ONLY* tagged with the specified tags
       #                       * <tt>:owned_by</tt> - return objects that are *ONLY* owned by the owner
       #
@@ -79,6 +79,7 @@ module ActsAsTaggableOn::Taggable
       #   User.tagged_with("awesome", "cool")                     # Users that are tagged with awesome and cool
       #   User.tagged_with("awesome", "cool", :exclude => true)   # Users that are not tagged with awesome or cool
       #   User.tagged_with("awesome", "cool", :any => true)       # Users that are tagged with awesome or cool
+      #   User.tagged_with("awesome", "cool", :any => true, :order_by_matching_tag_count => true)  # Sort by users who match the most tags, descending
       #   User.tagged_with("awesome", "cool", :match_all => true) # Users that are tagged with just awesome and cool
       #   User.tagged_with("awesome", "cool", :owned_by => foo ) # Users that are tagged with just awesome and cool by 'foo'
       def tagged_with(tags, options = {})
@@ -91,6 +92,7 @@ module ActsAsTaggableOn::Taggable
         conditions = []
         having = []
         select_clause = []
+        order_by = []
 
         context = options.delete(:on)
         owned_by = options.delete(:owned_by)
@@ -139,7 +141,7 @@ module ActsAsTaggableOn::Taggable
 
           # don't need to sanitize sql, map all ids and join with OR logic
           conditions << tags.map { |t| "#{taggings_alias}.tag_id = #{quote_value(t.id, nil)}" }.join(" OR ")
-          select_clause = "DISTINCT #{table_name}.*" unless context and tag_types.one?
+          select_clause = " #{table_name}.*" unless context and tag_types.one?
 
           if owned_by
               tagging_join << " AND " +
@@ -178,27 +180,35 @@ module ActsAsTaggableOn::Taggable
           end
         end
 
-        taggings_alias, tags_alias = adjust_taggings_alias("#{alias_base_name}_taggings_group"), "#{alias_base_name}_tags_group"
+        group = [] # Rails interprets this as a no-op in the group() call below
+        if options.delete(:order_by_matching_tag_count)
+          select_clause = "#{table_name}.*, COUNT(#{taggings_alias}.tag_id) AS #{taggings_alias}_count"
+          group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
+          group = group_columns
+          order_by << "#{taggings_alias}_count DESC"
 
-        if options.delete(:match_all)
+        elsif options.delete(:match_all)
+          taggings_alias, _ = adjust_taggings_alias("#{alias_base_name}_taggings_group"), "#{alias_base_name}_tags_group"
           joins << "LEFT OUTER JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
                    "  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}"
         end
 
-        select(select_clause) \
-          .joins(joins.join(" ")) \
-          .where(conditions.join(" AND ")) \
-          .group(group) \
-          .having(having) \
-          .order(options[:order]) \
-          .readonly(false)
+        order_by << options[:order] if options[:order].present?
+
+        request = select(select_clause).
+          joins(joins.join(" ")).
+          where(conditions.join(" AND ")).
+          group(group).
+          having(having).
+          order(order_by.join(", ")).
+          readonly(false)
+
+        ((context and tag_types.one?) && options.delete(:any)) ? request : request.uniq
       end
 
       def is_taggable?
@@ -217,179 +227,176 @@ module ActsAsTaggableOn::Taggable
       end
     end
 
-    module InstanceMethods
-      # all column names are necessary for PostgreSQL group clause
-      def grouped_column_names_for(object)
-        self.class.grouped_column_names_for(object)
-      end
+    # all column names are necessary for PostgreSQL group clause
+    def grouped_column_names_for(object)
+      self.class.grouped_column_names_for(object)
+    end
 
-      def custom_contexts
-        @custom_contexts ||= []
-      end
+    def custom_contexts
+      @custom_contexts ||= []
+    end
 
-      def is_taggable?
-        self.class.is_taggable?
-      end
+    def is_taggable?
+      self.class.is_taggable?
+    end
 
-      def add_custom_context(value)
-        custom_contexts << value.to_s unless custom_contexts.include?(value.to_s) or self.class.tag_types.map(&:to_s).include?(value.to_s)
-      end
+    def add_custom_context(value)
+      custom_contexts << value.to_s unless custom_contexts.include?(value.to_s) or self.class.tag_types.map(&:to_s).include?(value.to_s)
+    end
 
-      def cached_tag_list_on(context)
-        self["cached_#{context.to_s.singularize}_list"]
-      end
+    def cached_tag_list_on(context)
+      self["cached_#{context.to_s.singularize}_list"]
+    end
 
-      def tag_list_cache_set_on(context)
-        variable_name = "@#{context.to_s.singularize}_list"
-        instance_variable_defined?(variable_name) && !instance_variable_get(variable_name).nil?
-      end
+    def tag_list_cache_set_on(context)
+      variable_name = "@#{context.to_s.singularize}_list"
+      instance_variable_defined?(variable_name) && !instance_variable_get(variable_name).nil?
+    end
 
-      def tag_list_cache_on(context)
-        variable_name = "@#{context.to_s.singularize}_list"
-        if instance_variable_get(variable_name)
-          instance_variable_get(variable_name)
-        elsif cached_tag_list_on(context) && self.class.caching_tag_list_on?(context)
-          instance_variable_set(variable_name, ActsAsTaggableOn::TagList.from(cached_tag_list_on(context)))
-        else
-          instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
-        end
+    def tag_list_cache_on(context)
+      variable_name = "@#{context.to_s.singularize}_list"
+      if instance_variable_get(variable_name)
+        instance_variable_get(variable_name)
+      elsif cached_tag_list_on(context) && self.class.caching_tag_list_on?(context)
+        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.from(cached_tag_list_on(context)))
+      else
+        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
       end
+    end
 
-      def tag_list_on(context)
-        add_custom_context(context)
-        tag_list_cache_on(context)
-      end
+    def tag_list_on(context)
+      add_custom_context(context)
+      tag_list_cache_on(context)
+    end
 
-      def all_tags_list_on(context)
-        variable_name = "@all_#{context.to_s.singularize}_list"
-        return instance_variable_get(variable_name) if instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
+    def all_tags_list_on(context)
+      variable_name = "@all_#{context.to_s.singularize}_list"
+      return instance_variable_get(variable_name) if instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
 
-        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(all_tags_on(context).map(&:name)).freeze)
-      end
+      instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(all_tags_on(context).map(&:name)).freeze)
+    end
 
-      ##
-      # Returns all tags of a given context
-      def all_tags_on(context)
-        tag_table_name = ActsAsTaggableOn::Tag.table_name
-        tagging_table_name = ActsAsTaggableOn::Tagging.table_name
+    ##
+    # Returns all tags of a given context
+    def all_tags_on(context)
+      tagging_table_name = ActsAsTaggableOn::Tagging.table_name
 
-        opts  =  ["#{tagging_table_name}.context = ?", context.to_s]
-        scope = base_tags.where(opts)
+      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.order("max(#{tagging_table_name}.created_at)").group(group_columns)
-        else
-          scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
-        end.to_a
-      end
-
-      ##
-      # Returns all tags that are not owned of a given context
-      def tags_on(context)
-        scope = base_tags.where(["#{ActsAsTaggableOn::Tagging.table_name}.context = ? AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id IS NULL", context.to_s])
-        # when preserving tag order, return tags in created order
-        # if we added the order to the association this would always apply
-        scope = scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id") if self.class.preserve_tag_order?
-        scope
-      end
+      if ActsAsTaggableOn::Tag.using_postgresql?
+        group_columns = grouped_column_names_for(ActsAsTaggableOn::Tag)
+        scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
+      else
+        scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
+      end.to_a
+    end
 
-      def set_tag_list_on(context, new_list)
-        add_custom_context(context)
+    ##
+    # Returns all tags that are not owned of a given context
+    def tags_on(context)
+      scope = base_tags.where(["#{ActsAsTaggableOn::Tagging.table_name}.context = ? AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id IS NULL", context.to_s])
+      # when preserving tag order, return tags in created order
+      # if we added the order to the association this would always apply
+      scope = scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id") if self.class.preserve_tag_order?
+      scope
+    end
 
-        variable_name = "@#{context.to_s.singularize}_list"
-        process_dirty_object(context, new_list) unless custom_contexts.include?(context.to_s)
+    def set_tag_list_on(context, new_list)
+      add_custom_context(context)
 
-        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.from(new_list))
-      end
+      variable_name = "@#{context.to_s.singularize}_list"
+      process_dirty_object(context, new_list) unless custom_contexts.include?(context.to_s)
 
-      def tagging_contexts
-        custom_contexts + self.class.tag_types.map(&:to_s)
-      end
+      instance_variable_set(variable_name, ActsAsTaggableOn::TagList.from(new_list))
+    end
 
-      def process_dirty_object(context,new_list)
-        value = new_list.is_a?(Array) ? ActsAsTaggableOn::TagList.new(new_list) : new_list
-        attrib = "#{context.to_s.singularize}_list"
+    def tagging_contexts
+      custom_contexts + self.class.tag_types.map(&:to_s)
+    end
 
-        if changed_attributes.include?(attrib)
-          # The attribute already has an unsaved change.
-          old = changed_attributes[attrib]
-          changed_attributes.delete(attrib) if (old.to_s == value.to_s)
-        else
-          old = tag_list_on(context).to_s
-          changed_attributes[attrib] = old if (old.to_s != value.to_s)
-        end
+    def process_dirty_object(context,new_list)
+      value = new_list.is_a?(Array) ? ActsAsTaggableOn::TagList.new(new_list) : new_list
+      attrib = "#{context.to_s.singularize}_list"
+
+      if changed_attributes.include?(attrib)
+        # The attribute already has an unsaved change.
+        old = changed_attributes[attrib]
+        changed_attributes.delete(attrib) if (old.to_s == value.to_s)
+      else
+        old = tag_list_on(context).to_s
+        changed_attributes[attrib] = old if (old.to_s != value.to_s)
       end
+    end
 
-      def reload(*args)
-        self.class.tag_types.each do |context|
-          instance_variable_set("@#{context.to_s.singularize}_list", nil)
-          instance_variable_set("@all_#{context.to_s.singularize}_list", nil)
-        end
-
-        super(*args)
+    def reload(*args)
+      self.class.tag_types.each do |context|
+        instance_variable_set("@#{context.to_s.singularize}_list", nil)
+        instance_variable_set("@all_#{context.to_s.singularize}_list", nil)
       end
 
-      ##
-      # Find existing tags or create non-existing tags
-      def load_tags(tag_list)
-        ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list)
-      end
+      super(*args)
+    end
 
-      def save_tags
-        tagging_contexts.each do |context|
-          next unless tag_list_cache_set_on(context)
-          # List of currently assigned tag names
-          tag_list = tag_list_cache_on(context).uniq
+    ##
+    # Find existing tags or create non-existing tags
+    def load_tags(tag_list)
+      ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list)
+    end
 
-          # Find existing tags or create non-existing tags:
-          tags = load_tags(tag_list)
+    def save_tags
+      tagging_contexts.each do |context|
+        next unless tag_list_cache_set_on(context)
+        # List of currently assigned tag names
+        tag_list = tag_list_cache_on(context).uniq
 
-          # Tag objects for currently assigned tags
-          current_tags = tags_on(context)
+        # Find existing tags or create non-existing tags:
+        tags = load_tags(tag_list)
 
-          # Tag maintenance based on whether preserving the created order of tags
-          if self.class.preserve_tag_order?
-            old_tags, new_tags = current_tags - tags, tags - current_tags
+        # Tag objects for currently assigned tags
+        current_tags = tags_on(context)
 
-            shared_tags = current_tags & tags
+        # Tag maintenance based on whether preserving the created order of tags
+        if self.class.preserve_tag_order?
+          old_tags, new_tags = current_tags - tags, tags - current_tags
 
-            if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
-              index = shared_tags.each_with_index { |_, i| break i unless shared_tags[i] == tags[i] }
+          shared_tags = current_tags & tags
 
-              # Update arrays of tag objects
-              old_tags |= current_tags[index...current_tags.size]
-              new_tags |= current_tags[index...current_tags.size] & shared_tags
+          if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
+            index = shared_tags.each_with_index { |_, i| break i unless shared_tags[i] == tags[i] }
 
-              # Order the array of tag objects to match the tag list
-              new_tags = tags.map do |t|
-                new_tags.find { |n| n.name.downcase == t.name.downcase }
-              end.compact
-            end
-          else
-            # Delete discarded tags and create new tags
-            old_tags = current_tags - tags
-            new_tags = tags - current_tags
-          end
+            # Update arrays of tag objects
+            old_tags |= current_tags[index...current_tags.size]
+            new_tags |= current_tags[index...current_tags.size] & shared_tags
 
-          # Find taggings to remove:
-          if old_tags.present?
-            old_taggings = taggings.where(:tagger_type => nil, :tagger_id => nil, :context => context.to_s, :tag_id => old_tags)
+            # Order the array of tag objects to match the tag list
+            new_tags = tags.map do |t|
+              new_tags.find { |n| n.name.downcase == t.name.downcase }
+            end.compact
           end
+        else
+          # Delete discarded tags and create new tags
+          old_tags = current_tags - tags
+          new_tags = tags - current_tags
+        end
 
-          # Destroy old taggings:
-          if old_taggings.present?
-            ActsAsTaggableOn::Tagging.destroy_all "#{ActsAsTaggableOn::Tagging.primary_key}".to_sym => old_taggings.map(&:id)
-          end
+        # Find taggings to remove:
+        if old_tags.present?
+          old_taggings = taggings.where(:tagger_type => nil, :tagger_id => nil, :context => context.to_s, :tag_id => old_tags)
+        end
 
-          # Create new taggings:
-          new_tags.each do |tag|
-            taggings.create!(:tag_id => tag.id, :context => context.to_s, :taggable => self)
-          end
+        # Destroy old taggings:
+        if old_taggings.present?
+          ActsAsTaggableOn::Tagging.destroy_all "#{ActsAsTaggableOn::Tagging.primary_key}".to_sym => old_taggings.map(&:id)
         end
 
-        true
+        # Create new taggings:
+        new_tags.each do |tag|
+          taggings.create!(:tag_id => tag.id, :context => context.to_s, :taggable => self)
+        end
       end
+
+      true
     end
   end
 end

data/lib/acts_as_taggable_on/acts_as_taggable_on/dirty.rb

@@ -10,7 +10,6 @@ module ActsAsTaggableOn::Taggable
       def initialize_acts_as_taggable_on_dirty
         tag_types.map(&:to_s).each do |tags_type|
           tag_type         = tags_type.to_s.singularize
-          context_tags     = tags_type.to_sym
 
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{tag_type}_list_changed?

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -1,135 +1,132 @@
 module ActsAsTaggableOn::Taggable
   module Ownership
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Ownership::InstanceMethods
       base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
-     
+
       base.class_eval do
-        after_save :save_owned_tags    
+        after_save :save_owned_tags
       end
-      
+
       base.initialize_acts_as_taggable_on_ownership
     end
-    
+
     module ClassMethods
       def acts_as_taggable_on(*args)
         initialize_acts_as_taggable_on_ownership
         super(*args)
       end
-      
-      def initialize_acts_as_taggable_on_ownership      
+
+      def initialize_acts_as_taggable_on_ownership
         tag_types.map(&:to_s).each do |tag_type|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{tag_type}_from(owner)
               owner_tag_list_on(owner, '#{tag_type}')
-            end      
+            end
           RUBY
-        end        
+        end
       end
     end
-    
-    module InstanceMethods
-      def owner_tags_on(owner, context)
-        if owner.nil?
-          scope = base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ?), context.to_s])                    
-        else
-          scope = 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.base_class.to_s])          
-        end
 
-        # when preserving tag order, return tags in created order
-        # if we added the order to the association this would always apply
-        if self.class.preserve_tag_order?
-          scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id")
-        else 
-          scope
-        end
+    def owner_tags_on(owner, context)
+      if owner.nil?
+        scope = base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ?), context.to_s])
+      else
+        scope = 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.base_class.to_s])
       end
 
-      def cached_owned_tag_list_on(context)
-        variable_name = "@owned_#{context}_list"
-        cache = (instance_variable_defined?(variable_name) && instance_variable_get(variable_name)) || instance_variable_set(variable_name, {})
+      # when preserving tag order, return tags in created order
+      # if we added the order to the association this would always apply
+      if self.class.preserve_tag_order?
+        scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id")
+      else
+        scope
       end
-      
-      def owner_tag_list_on(owner, context)
-        add_custom_context(context)
+    end
 
-        cache = cached_owned_tag_list_on(context)
-        
-        cache[owner] ||= ActsAsTaggableOn::TagList.new(*owner_tags_on(owner, context).map(&:name))
-      end
-      
-      def set_owner_tag_list_on(owner, context, new_list)
-        add_custom_context(context)
-        
-        cache = cached_owned_tag_list_on(context)
+    def cached_owned_tag_list_on(context)
+      variable_name = "@owned_#{context}_list"
+      (instance_variable_defined?(variable_name) && instance_variable_get(variable_name)) || instance_variable_set(variable_name, {})
+    end
 
-        cache[owner] = ActsAsTaggableOn::TagList.from(new_list)
-      end
-      
-      def reload(*args)
-        self.class.tag_types.each do |context|
-          instance_variable_set("@owned_#{context}_list", nil)
-        end
-      
-        super(*args)
+    def owner_tag_list_on(owner, context)
+      add_custom_context(context)
+
+      cache = cached_owned_tag_list_on(context)
+
+      cache[owner] ||= ActsAsTaggableOn::TagList.new(*owner_tags_on(owner, context).map(&:name))
+    end
+
+    def set_owner_tag_list_on(owner, context, new_list)
+      add_custom_context(context)
+
+      cache = cached_owned_tag_list_on(context)
+
+      cache[owner] = ActsAsTaggableOn::TagList.from(new_list)
+    end
+
+    def reload(*args)
+      self.class.tag_types.each do |context|
+        instance_variable_set("@owned_#{context}_list", nil)
       end
-    
-      def save_owned_tags
-        tagging_contexts.each do |context|
-          cached_owned_tag_list_on(context).each do |owner, tag_list|
-            
-            # Find existing tags or create non-existing tags:
-            tags = ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list.uniq)            
-
-            # Tag objects for owned tags
-            owned_tags = owner_tags_on(owner, context)
-               
-            # Tag maintenance based on whether preserving the created order of tags
-            if self.class.preserve_tag_order?
-              old_tags, new_tags = owned_tags - tags, tags - owned_tags
-
-              shared_tags = owned_tags & tags
-
-              if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
-                index = shared_tags.each_with_index { |_, i| break i unless shared_tags[i] == tags[i] }
-
-                # Update arrays of tag objects
-                old_tags |= owned_tags.from(index)
-                new_tags |= owned_tags.from(index) & shared_tags
-
-                # Order the array of tag objects to match the tag list
-                new_tags = tags.map { |t| new_tags.find { |n| n.name.downcase == t.name.downcase } }.compact
-              end
-            else
-              # Delete discarded tags and create new tags
-              old_tags = owned_tags - tags
-              new_tags = tags - owned_tags
-            end
-          
-            # Find all taggings that belong to the taggable (self), are owned by the owner, 
-            # have the correct context, and are removed from the list.
-            if old_tags.present?
-              old_taggings = ActsAsTaggableOn::Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
-                                                             :tagger_type => owner.class.base_class.to_s, :tagger_id => owner.id,
-                                                             :tag_id => old_tags, :context => context)
-            end
-          
-            # Destroy old taggings:
-            if old_taggings.present?
-              ActsAsTaggableOn::Tagging.destroy_all(:id => old_taggings.map(&:id))
-            end
 
-            # Create new taggings:
-            new_tags.each do |tag|
-              taggings.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
+      super(*args)
+    end
+
+    def save_owned_tags
+      tagging_contexts.each do |context|
+        cached_owned_tag_list_on(context).each do |owner, tag_list|
+
+          # Find existing tags or create non-existing tags:
+          tags = ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list.uniq)
+
+          # Tag objects for owned tags
+          owned_tags = owner_tags_on(owner, context)
+
+          # Tag maintenance based on whether preserving the created order of tags
+          if self.class.preserve_tag_order?
+            old_tags, new_tags = owned_tags - tags, tags - owned_tags
+
+            shared_tags = owned_tags & tags
+
+            if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
+              index = shared_tags.each_with_index { |_, i| break i unless shared_tags[i] == tags[i] }
+
+              # Update arrays of tag objects
+              old_tags |= owned_tags.from(index)
+              new_tags |= owned_tags.from(index) & shared_tags
+
+              # Order the array of tag objects to match the tag list
+              new_tags = tags.map { |t| new_tags.find { |n| n.name.downcase == t.name.downcase } }.compact
             end
+          else
+            # Delete discarded tags and create new tags
+            old_tags = owned_tags - tags
+            new_tags = tags - owned_tags
+          end
+
+          # Find all taggings that belong to the taggable (self), are owned by the owner,
+          # have the correct context, and are removed from the list.
+          if old_tags.present?
+            old_taggings = ActsAsTaggableOn::Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
+                                                            :tagger_type => owner.class.base_class.to_s, :tagger_id => owner.id,
+                                                            :tag_id => old_tags, :context => context)
+          end
+
+          # Destroy old taggings:
+          if old_taggings.present?
+            ActsAsTaggableOn::Tagging.destroy_all(:id => old_taggings.map(&:id))
+          end
+
+          # Create new taggings:
+          new_tags.each do |tag|
+            taggings.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
           end
         end
-        
-        true
       end
+
+      true
     end
   end
 end

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -1,7 +1,6 @@
 module ActsAsTaggableOn::Taggable
   module Related
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Related::InstanceMethods
       base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
       base.initialize_acts_as_taggable_on_related
     end
@@ -20,18 +19,6 @@ module ActsAsTaggableOn::Taggable
             end
           RUBY
         end
-
-        unless tag_types.empty?
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def find_matching_contexts(search_context, result_context, options = {})
-              matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
-            end
-
-            def find_matching_contexts_for(klass, search_context, result_context, options = {})
-              matching_contexts_for(search_context.to_s, result_context.to_s, klass, options)
-            end
-          RUBY
-        end
       end
 
       def acts_as_taggable_on(*args)
@@ -40,44 +27,50 @@ module ActsAsTaggableOn::Taggable
       end
     end
 
-    module InstanceMethods
-      def matching_contexts_for(search_context, result_context, klass, options = {})
-        tags_to_find = tags_on(search_context).collect { |t| t.name }
+    def find_matching_contexts(search_context, result_context, options = {})
+      matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
+    end
 
-        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")
-      end
+    def find_matching_contexts_for(klass, search_context, result_context, options = {})
+      matching_contexts_for(search_context.to_s, result_context.to_s, klass, options)
+    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 }
+    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 (?)", tags_to_find]) \
-             .group(group_columns(klass)) \
-             .order("count DESC")
-      end
+      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")
+    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
+    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")
+    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
+    end
 
-      def group_columns(klass)
-        if ActsAsTaggableOn::Tag.using_postgresql? 
-          grouped_column_names_for(klass)
-        else
-          "#{klass.table_name}.#{klass.primary_key}"
-        end
+    def group_columns(klass)
+      if ActsAsTaggableOn::Tag.using_postgresql?
+        grouped_column_names_for(klass)
+      else
+        "#{klass.table_name}.#{klass.primary_key}"
       end
     end
   end

data/lib/acts_as_taggable_on/tag.rb

@@ -1,7 +1,7 @@
 # coding: utf-8
 module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
-    include ActsAsTaggableOn::Utils
+    extend ActsAsTaggableOn::Utils
 
     attr_accessible :name if defined?(ActiveModel::MassAssignmentSecurity)
 

data/lib/acts_as_taggable_on/taggable.rb

@@ -87,7 +87,7 @@ module ActsAsTaggableOn
               true
             end
 
-            include ActsAsTaggableOn::Utils
+            extend ActsAsTaggableOn::Utils
           end
         end
 

data/lib/acts_as_taggable_on/utils.rb

@@ -1,34 +1,26 @@
 module ActsAsTaggableOn
   module Utils
-    def self.included(base)
-
-      base.send :include, ActsAsTaggableOn::Utils::OverallMethods
-      base.extend ActsAsTaggableOn::Utils::OverallMethods
+    def using_postgresql?
+      ::ActiveRecord::Base.connection && ::ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
     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
 
-      def using_sqlite?
-        ::ActiveRecord::Base.connection && ::ActiveRecord::Base.connection.adapter_name == 'SQLite'
-      end
+    def sha_prefix(string)
+      Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
+    end
 
-      def sha_prefix(string)
-        Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
-      end
-      
-      private
-      def like_operator
-        using_postgresql? ? 'ILIKE' : 'LIKE'
-      end
+    private
 
-      # escape _ and % characters in strings, since these are wildcards in SQL.
-       def escape_like(str)
-         str.gsub(/[!%_]/){ |x| '!' + x }
-       end
+    def like_operator
+      using_postgresql? ? 'ILIKE' : 'LIKE'
     end
 
+    # escape _ and % characters in strings, since these are wildcards in SQL.
+    def escape_like(str)
+      str.gsub(/[!%_]/){ |x| '!' + x }
+    end
   end
 end

data/lib/acts_as_taggable_on/version.rb

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

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -216,6 +216,13 @@ describe "Taggable" do
     TaggableModel.tagged_with("ruby").first.should == @taggable
   end
 
+  it "should be able to get a count with find by tag when using a group by" do
+    @taggable.skill_list = "ruby"
+    @taggable.save
+
+    expect(TaggableModel.tagged_with("ruby").group(:created_at).count.count).to eq(1)
+  end
+
   it "should be able to find by tag with context" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.tag_list = "bob, charlie"
@@ -369,6 +376,18 @@ describe "Taggable" do
     TaggableModel.tagged_with(["depressed", "css"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, frank]
   end
 
+  it "should be able to order by number of matching tags when matching any" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
+    steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
+
+    TaggableModel.tagged_with(["ruby", "java"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [steve, bob, frank]
+    TaggableModel.tagged_with(["c++", "fitter"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [steve, bob]
+    TaggableModel.tagged_with(["depressed", "css"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [frank, bob]
+    TaggableModel.tagged_with(["fitter", "happier", "more productive", "c++", "java", "ruby"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [steve, bob, frank]
+    TaggableModel.tagged_with(["c++", "java", "ruby", "fitter"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [steve, bob, frank]
+  end
+
   context "wild: true" do
     it "should use params as wildcards" do
       bob = TaggableModel.create(:name => "Bob", :tag_list => "bob, tricia")
@@ -411,14 +430,6 @@ 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")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts-as-taggable-on
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.1.0.rc1
 platform: ruby
 authors:
 - Michael Bleigh
@@ -9,10 +9,50 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-12 00:00:00.000000000 Z
+date: 2014-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -194,12 +234,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Advanced tagging for Rails.