acts-as-taggable-on 3.2.1 → 3.4.0

data/lib/acts_as_taggable_on/tag_list.rb

@@ -1,89 +1,16 @@
+
 require 'active_support/core_ext/module/delegation'
 
 module ActsAsTaggableOn
   class TagList < Array
     attr_accessor :owner
+    attr_accessor :parser
 
     def initialize(*args)
+      @parser = ActsAsTaggableOn.default_parser
       add(*args)
     end
 
-    class << self
-      ##
-      # Returns a new TagList using the given tag string.
-      #
-      # Example:
-      #   tag_list = ActsAsTaggableOn::TagList.from("One , Two,  Three")
-      #   tag_list # ["One", "Two", "Three"]
-      def from(string)
-        string = string.join(ActsAsTaggableOn.glue) if string.respond_to?(:join)
-
-        new.tap do |tag_list|
-          string = string.to_s.dup
-
-
-          string.gsub!(double_quote_pattern) {
-            # Append the matched tag to the tag list
-            tag_list << Regexp.last_match[2]
-            # Return the matched delimiter ($3) to replace the matched items
-            ''
-          }
-
-          string.gsub!(single_quote_pattern) {
-            # Append the matched tag ($2) to the tag list
-            tag_list << Regexp.last_match[2]
-            # Return an empty string to replace the matched items
-            ''
-          }
-
-          # split the string by the delimiter
-          # and add to the tag_list
-          tag_list.add(string.split(Regexp.new delimiter))
-        end
-      end
-
-      def delimiter
-        # Parse the quoted tags
-        d = ActsAsTaggableOn.delimiter
-        # Separate multiple delimiters by bitwise operator
-        d = d.join('|') if d.kind_of?(Array)
-
-        d
-      end
-
-      def single_quote_pattern
-        %r{
-          (             # Tag start delimiter ($1)
-            \A       |  # Either string start or
-            #{delimiter}        # a delimiter
-          )
-          \s*'          # quote (') optionally preceded by whitespace
-          (.*?)         # Tag ($2)
-          '\s*          # quote (') optionally followed by whitespace
-          (?=           # Tag end delimiter (not consumed; is zero-length lookahead)
-            #{delimiter}\s*  |  # Either a delimiter optionally followed by whitespace or
-            \z          # string end
-          )
-      }x
-      end
-
-      def double_quote_pattern
-        %r{
-          (             # Tag start delimiter ($1)
-            \A       |  # Either string start or
-            #{delimiter}        # a delimiter
-          )
-          \s*"          # quote (") optionally preceded by whitespace
-          (.*?)         # Tag ($2)
-          "\s*          # quote (") optionally followed by whitespace
-          (?=           # Tag end delimiter (not consumed; is zero-length lookahead)
-            #{delimiter}\s*  |  # Either a delimiter optionally followed by whitespace or
-            \z          # string end
-          )
-      }x
-      end
-
-    end
     ##
     # Add tags to the tag_list. Duplicate or blank tags will be ignored.
     # Use the <tt>:parse</tt> option to add an unparsed tag string.
@@ -149,9 +76,10 @@ module ActsAsTaggableOn
 
     private
 
-    # Remove whitespace, duplicates, and blanks.
+    # Convert everything to string, remove whitespace, duplicates, and blanks.
     def clean!
       reject!(&:blank?)
+      map!(&:to_s)
       map!(&:strip)
       map! { |tag| tag.mb_chars.downcase.to_s } if ActsAsTaggableOn.force_lowercase
       map!(&:parameterize) if ActsAsTaggableOn.force_parameterize
@@ -162,14 +90,27 @@ module ActsAsTaggableOn
 
     def extract_and_apply_options!(args)
       options = args.last.is_a?(Hash) ? args.pop : {}
-      options.assert_valid_keys :parse
+      options.assert_valid_keys :parse, :parser
 
-      args.map! { |a| self.class.from(a) } if options[:parse]
+      parser = options[:parser] ? options[:parser] : @parser
+
+      args.map! { |a| parser.new(a).parse } if options[:parse] || options[:parser]
 
       args.flatten!
     end
 
 
+    ## DEPRECATED
+    def self.from(string)
+      ActiveRecord::Base.logger.warn <<WARNING
+ActsAsTaggableOn::TagList.from is deprecated \
+and will be removed from v4.0+, use  \
+ActsAsTaggableOn::DefaultParser.new instead
+WARNING
+      @parser.new(string).parse
+    end
+
+
   end
 end
 

data/lib/acts_as_taggable_on/tag_list_parser.rb

@@ -0,0 +1,21 @@
+module ActsAsTaggableOn
+  ##
+  # Returns a new TagList using the given tag string.
+  #
+  # Example:
+  #   tag_list = ActsAsTaggableOn::TagListParser.parse("One , Two,  Three")
+  #   tag_list # ["One", "Two", "Three"]
+  module TagListParser
+    class << self
+      ## DEPRECATED
+      def parse(string)
+        ActiveRecord::Base.logger.warn <<WARNING
+ActsAsTaggableOn::TagListParser.parse is deprecated \
+and will be removed from v4.0+, use  \
+ActsAsTaggableOn::TagListParser.new instead
+WARNING
+        DefaultParser.new(string).parse
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/{acts_as_taggable_on → taggable}/cache.rb

@@ -31,6 +31,7 @@ module ActsAsTaggableOn::Taggable
         #   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

data/lib/acts_as_taggable_on/{acts_as_taggable_on → taggable}/collection.rb

@@ -53,6 +53,7 @@ module ActsAsTaggableOn::Taggable
       #                       * :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 = options.dup
         options.assert_valid_keys :start_at, :end_at, :conditions, :order, :limit, :on
 
         ## Generate conditions:
@@ -87,6 +88,7 @@ module ActsAsTaggableOn::Taggable
       #                       * :at_most    - Exclude tags with a frequency greater than the given value
       #                       * :on         - Scope the find to only include a certain context
       def all_tag_counts(options = {})
+        options = options.dup
         options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
 
         ## Generate conditions:
@@ -133,7 +135,7 @@ module ActsAsTaggableOn::Taggable
         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)
+          scoped_ids = pluck(table_name_pkey)
           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))})")

data/lib/acts_as_taggable_on/{acts_as_taggable_on → taggable}/core.rb

@@ -24,16 +24,16 @@ module ActsAsTaggableOn::Taggable
             # when preserving tag order, include order option so that for a 'tags' context
             # the associations tag_taggings & tags are always returned in created order
             has_many_with_taggable_compatibility context_taggings, as: :taggable,
-                                                                   dependent: :destroy,
-                                                                   class_name: 'ActsAsTaggableOn::Tagging',
-                                                                   order: taggings_order,
-                                                                   conditions: ["#{ActsAsTaggableOn::Tagging.table_name}.context = (?)", tags_type],
-                                                                   include: :tag
+                                                 dependent: :destroy,
+                                                 class_name: 'ActsAsTaggableOn::Tagging',
+                                                 order: taggings_order,
+                                                 conditions: ["#{ActsAsTaggableOn::Tagging.table_name}.context = (?)", tags_type],
+                                                 include: :tag
 
             has_many_with_taggable_compatibility context_tags, through: context_taggings,
-                                                               source: :tag,
-                                                               class_name: 'ActsAsTaggableOn::Tag',
-                                                               order: taggings_order
+                                                 source: :tag,
+                                                 class_name: 'ActsAsTaggableOn::Tag',
+                                                 order: taggings_order
 
           end
 
@@ -73,16 +73,20 @@ module ActsAsTaggableOn::Taggable
       #                       * <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
+      #                       * <tt>:start_at</tt> - Restrict the tags to those created after a certain time
+      #                       * <tt>:end_at</tt> - Restrict the tags to those created before a certain time
       #
       # Example:
-      #   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'
+      #   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'
+      #   User.tagged_with(["awesome", "cool"], :owned_by => foo, :start_at => Date.today ) # Users that are tagged with just awesome, cool by 'foo' and starting today
       def tagged_with(tags, options = {})
-        tag_list = ActsAsTaggableOn::TagList.from(tags)
+        tag_list = ActsAsTaggableOn.default_parser.new(tags).parse
+        options = options.dup
         empty_result = where('1 = 0')
 
         return empty_result if tag_list.empty?
@@ -108,14 +112,17 @@ module ActsAsTaggableOn::Taggable
           conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name, nil)})"
 
           if owned_by
-            joins << "JOIN #{ActsAsTaggableOn::Tagging.table_name}" \
-                "  ON #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" \
-                " AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name, nil)}" \
-                " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = #{quote_value(owned_by.id, nil)}" \
-                " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = #{quote_value(owned_by.class.base_class.to_s, nil)}"
+            joins <<  "JOIN #{ActsAsTaggableOn::Tagging.table_name}" +
+                      "  ON #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name, nil)}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = #{quote_value(owned_by.id, nil)}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = #{quote_value(owned_by.class.base_class.to_s, nil)}"
+            
+            joins << " AND " + sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+            joins << " AND " + sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
           end
 
-        elsif options.delete(:any)
+        elsif any = options.delete(:any)
           # get tags, drop out if nothing returned (we need at least one)
           tags = if options.delete(:wild)
                    ActsAsTaggableOn::Tag.named_like_any(tag_list)
@@ -130,49 +137,59 @@ module ActsAsTaggableOn::Taggable
           taggings_context = context ? "_#{context}" : ''
 
           taggings_alias = adjust_taggings_alias(
-              "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{sha_prefix(tags.map(&:name).join('_'))}"
+              "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tags.map(&:name).join('_'))}"
           )
 
-          tagging_join = "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)}"
-          tagging_join << ' AND ' + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+          tagging_join = "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)}"
+
+          tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+          tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
+
+          tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
           # don't need to sanitize sql, map all ids and join with OR logic
           conditions << tags.map { |t| "#{taggings_alias}.tag_id = #{quote_value(t.id, nil)}" }.join(' OR ')
-          select_clause = " #{table_name}.*" unless context and tag_types.one?
+          select_clause << " #{table_name}.*" unless context and tag_types.one?
 
           if owned_by
             tagging_join << ' AND ' +
                 sanitize_sql([
-                  "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
-                  owned_by.id,
-                  owned_by.class.base_class.to_s
+                                 "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
+                                 owned_by.id,
+                                 owned_by.class.base_class.to_s
                              ])
           end
 
           joins << tagging_join
-          group = "#{table_name}.#{primary_key}"
+          unless any == 'distinct' # Fix issue #544
+            group = "#{table_name}.#{primary_key}"
+            select_clause << group
+          end
         else
           tags = ActsAsTaggableOn::Tag.named_any(tag_list)
 
           return empty_result unless tags.length == tag_list.length
 
           tags.each do |tag|
-            taggings_alias = adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{sha_prefix(tag.name)}")
+            taggings_alias = adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag.name)}")
             tagging_join = "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)}" +
                 " AND #{taggings_alias}.tag_id = #{quote_value(tag.id, nil)}"
 
-            tagging_join << ' AND ' + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+            tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+            tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
+
+            tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
             if owned_by
               tagging_join << ' AND ' +
                   sanitize_sql([
-                    "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
-                    owned_by.id,
-                    owned_by.class.base_class.to_s
+                                   "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
+                                   owned_by.id,
+                                   owned_by.class.base_class.to_s
                                ])
             end
 
@@ -182,7 +199,7 @@ module ActsAsTaggableOn::Taggable
 
         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"
+          select_clause << "#{table_name}.*, COUNT(#{taggings_alias}.tag_id) AS #{taggings_alias}_count"
           group_columns = ActsAsTaggableOn::Utils.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
           group = group_columns
           order_by << "#{taggings_alias}_count DESC"
@@ -193,7 +210,9 @@ 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
+          joins << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
+          joins << " AND " + sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+          joins << " AND " + sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
 
           group_columns = ActsAsTaggableOn::Utils.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
           group = group_columns
@@ -202,13 +221,14 @@ module ActsAsTaggableOn::Taggable
 
         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)
+        query = self
+        query = self.select(select_clause.join(',')) unless select_clause.empty?
+        query.joins(joins.join(' '))
+        .where(conditions.join(' AND '))
+        .group(group)
+        .having(having)
+        .order(order_by.join(', '))
+        .readonly(false)
       end
 
       def is_taggable?
@@ -258,7 +278,7 @@ module ActsAsTaggableOn::Taggable
       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)))
+        instance_variable_set(variable_name, ActsAsTaggableOn.default_parser.new(cached_tag_list_on(context)).parse)
       else
         instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
       end
@@ -308,7 +328,7 @@ module ActsAsTaggableOn::Taggable
       variable_name = "@#{context.to_s.singularize}_list"
       process_dirty_object(context, new_list) unless custom_contexts.include?(context.to_s)
 
-      instance_variable_set(variable_name, ActsAsTaggableOn::TagList.from(new_list))
+      instance_variable_set(variable_name, ActsAsTaggableOn.default_parser.new(new_list).parse)
     end
 
     def tagging_contexts
@@ -322,10 +342,14 @@ module ActsAsTaggableOn::Taggable
       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
+        @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
+        old = tag_list_on(context)
+        if self.class.preserve_tag_order
+          @changed_attributes[attrib] = old if old.to_s != value.to_s
+        else
+          @changed_attributes[attrib] = old.to_s if old.sort != ActsAsTaggableOn.default_parser.new(value).parse.sort
+        end
       end
     end
 
@@ -382,7 +406,7 @@ module ActsAsTaggableOn::Taggable
 
         # Destroy old taggings:
         if old_tags.present?
-          ActsAsTaggableOn::Tagging.destroy_all(tagger_type: nil, tagger_id: nil, context: context.to_s, tag_id: old_tags)
+          taggings.not_owned.by_context(context).destroy_all(tag_id: old_tags)
         end
 
         # Create new taggings:
@@ -396,6 +420,18 @@ module ActsAsTaggableOn::Taggable
 
     private
 
+    # Filters the tag lists from the attribute names.
+    def attributes_for_update(attribute_names)
+      tag_lists = tag_types.map {|tags_type| "#{tags_type.to_s.singularize}_list"}
+      super.delete_if {|attr| tag_lists.include? attr }
+    end
+
+    # Filters the tag lists from the attribute names.
+    def attributes_for_create(attribute_names)
+      tag_lists = tag_types.map {|tags_type| "#{tags_type.to_s.singularize}_list"}
+      super.delete_if {|attr| tag_lists.include? attr }
+    end
+    
     ##
     # Override this hook if you wish to subclass {ActsAsTaggableOn::Tag} --
     # context is provided so that you may conditionally use a Tag subclass

data/lib/acts_as_taggable_on/{acts_as_taggable_on → taggable}/ownership.rb

@@ -63,7 +63,7 @@ module ActsAsTaggableOn::Taggable
 
       cache = cached_owned_tag_list_on(context)
 
-      cache[owner] = ActsAsTaggableOn::TagList.from(new_list)
+      cache[owner] = ActsAsTaggableOn.default_parser.new(new_list).parse
     end
 
     def reload(*args)

data/lib/acts_as_taggable_on/{acts_as_taggable_on → taggable}/related.rb

@@ -41,7 +41,7 @@ module ActsAsTaggableOn::Taggable
     end
 
     def related_tags_for(context, klass, options = {})
-      tags_to_ignore = Array.wrap(options.delete(:ignore)).map(&:to_s) || []
+      tags_to_ignore = Array.wrap(options[:ignore]).map(&:to_s) || []
       tags_to_find = tags_on(context).map { |t| t.name }.reject { |t| tags_to_ignore.include? t }
       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}' 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
@@ -61,11 +61,11 @@ module ActsAsTaggableOn::Taggable
     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)
+      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/taggable.rb

@@ -1,5 +1,6 @@
 module ActsAsTaggableOn
   module Taggable
+
     def taggable?
       false
     end
@@ -85,19 +86,17 @@ module ActsAsTaggableOn
           def self.taggable?
             true
           end
-
-          extend ActsAsTaggableOn::Utils
         end
       end
 
       # each of these add context-specific methods and must be
       # called on each call of taggable_on
-      include ActsAsTaggableOn::Taggable::Core
-      include ActsAsTaggableOn::Taggable::Collection
-      include ActsAsTaggableOn::Taggable::Cache
-      include ActsAsTaggableOn::Taggable::Ownership
-      include ActsAsTaggableOn::Taggable::Related
-      include ActsAsTaggableOn::Taggable::Dirty
+      include Core
+      include Collection
+      include Cache
+      include Ownership
+      include Related
+      include Dirty
     end
   end
 end

data/lib/acts_as_taggable_on/tagging.rb

@@ -15,6 +15,12 @@ module ActsAsTaggableOn
     belongs_to :taggable, polymorphic: true
     belongs_to :tagger,   polymorphic: true
 
+    scope :owned_by, ->(owner) { where(tagger: owner) }
+    scope :not_owned, -> { where(tagger_id: nil, tagger_type: nil) }
+
+    scope :by_contexts, ->(contexts = ['tags']) { where(context: contexts) }
+    scope :by_context, ->(context= 'tags') { by_contexts(context.to_s) }
+
     validates_presence_of :context
     validates_presence_of :tag_id
 
@@ -26,7 +32,7 @@ module ActsAsTaggableOn
 
     def remove_unused_tags
       if ActsAsTaggableOn.remove_unused_tags
-        tag.destroy if tag.taggings_count.zero?
+        tag.destroy if tag.reload.taggings_count.zero?
       end
     end
   end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -4,10 +4,10 @@ module ActsAsTaggableOn
     def tag_cloud(tags, classes)
       return [] if tags.empty?
 
-      max_count = tags.sort_by(&:count).last.count.to_f
+      max_count = tags.sort_by(&:taggings_count).last.taggings_count.to_f
 
       tags.each do |tag|
-        index = ((tag.count / max_count) * (classes.size - 1))
+        index = ((tag.taggings_count / max_count) * (classes.size - 1))
         yield tag, classes[index.nan? ? 0 : index.round]
       end
     end

data/lib/acts_as_taggable_on/utils.rb

@@ -1,62 +1,38 @@
+# This module is deprecated and will be removed in the incoming versions
+
 module ActsAsTaggableOn
   module Utils
-    extend self
-
-    # Use ActsAsTaggableOn::Tag connection
-    def connection
-      ActsAsTaggableOn::Tag.connection
-    end
-
-    def using_postgresql?
-      connection && connection.adapter_name == 'PostgreSQL'
-    end
-
-    def postgresql_version
-      if using_postgresql?
-        connection.execute("SHOW SERVER_VERSION").first["server_version"].to_f
+    class << self
+      # Use ActsAsTaggableOn::Tag connection
+      def connection
+        ActsAsTaggableOn::Tag.connection
       end
-    end
-
-    def postgresql_support_json?
-      postgresql_version >= 9.2
-    end
-
-    def using_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? && connection.collation =~ /_ci\Z/
-    end
-
-    def supports_concurrency?
-      !using_sqlite?
-    end
+      def using_postgresql?
+        connection && connection.adapter_name == 'PostgreSQL'
+      end
 
-    def sha_prefix(string)
-      Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
-    end
+      def using_mysql?
+        #We should probably use regex for mysql to support prehistoric adapters
+        connection && connection.adapter_name == 'Mysql2'
+      end
 
-    def active_record4?
-      ::ActiveRecord::VERSION::MAJOR == 4
-    end
+      def sha_prefix(string)
+        Digest::SHA1.hexdigest("#{string}#{rand}")[0..6]
+      end
 
-    def active_record42?
-      active_record4? && ::ActiveRecord::VERSION::MINOR >= 2
-    end
+      def active_record4?
+        ::ActiveRecord::VERSION::MAJOR == 4
+      end
 
-    def like_operator
-      using_postgresql? ? 'ILIKE' : 'LIKE'
-    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 }
+      # escape _ and % characters in strings, since these are wildcards in SQL.
+      def escape_like(str)
+        str.gsub(/[!%_]/) { |x| '!' + x }
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/version.rb

@@ -1,4 +1,4 @@
 module ActsAsTaggableOn
-  VERSION = '3.2.1'
+  VERSION = '3.4.0'
 end
 

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -1,4 +1,4 @@
-# coding: utf-8
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 describe 'Acts As Taggable On' do