acts-as-taggable-on 3.1.1 → 3.2.1

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -34,9 +34,7 @@ module ActsAsTaggableOn::Taggable
         def columns
           @acts_as_taggable_on_cache_columns ||= begin
             db_columns = super
-            if _has_tags_cache_columns?(db_columns)
-              _add_tags_caching_methods
-            end
+            _add_tags_caching_methods if _has_tags_cache_columns?(db_columns)
             db_columns
           end
         end
@@ -79,6 +77,5 @@ module ActsAsTaggableOn::Taggable
         true
       end
     end
-
   end
 end

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -18,11 +18,11 @@ module ActsAsTaggableOn::Taggable
             end
 
             def top_#{tag_type}(limit = 10)
-              tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
+              tag_counts_on('#{tag_type}', order: 'count desc', limit: limit.to_i)
             end
 
             def self.top_#{tag_type}(limit = 10)
-              tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
+              tag_counts_on('#{tag_type}', order: 'count desc', limit: limit.to_i)
             end
           RUBY
         end
@@ -34,11 +34,11 @@ module ActsAsTaggableOn::Taggable
       end
 
       def tag_counts_on(context, options = {})
-        all_tag_counts(options.merge({:on => context.to_s}))
+        all_tag_counts(options.merge({on: context.to_s}))
       end
 
       def tags_on(context, options = {})
-        all_tags(options.merge({:on => context.to_s}))
+        all_tags(options.merge({on: context.to_s}))
       end
 
       ##
@@ -64,18 +64,16 @@ module ActsAsTaggableOn::Taggable
 
         # Joins and conditions
         tagging_conditions(options).each { |condition| tagging_scope = tagging_scope.where(condition) }
-        tag_scope     = tag_scope.where(options[:conditions])
+        tag_scope = tag_scope.where(options[:conditions])
 
         group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
 
         # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
-        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)
+        tagging_scope = generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key).group(group_columns)
 
         tag_scope_joins(tag_scope, tagging_scope)
       end
 
-
       ##
       # Calculate the tag counts for all tags.
       #
@@ -98,7 +96,6 @@ module ActsAsTaggableOn::Taggable
         taggable_join = "INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id"
         taggable_join << " AND #{table_name}.#{inheritance_column} = '#{name}'" unless descends_from_active_record? # Current model is STI descendant, so add type checking to the join condition
 
-
         ## Generate scope:
         tagging_scope = ActsAsTaggableOn::Tagging.select("#{ActsAsTaggableOn::Tagging.table_name}.tag_id, COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) AS tags_count")
         tag_scope = ActsAsTaggableOn::Tag.select("#{ActsAsTaggableOn::Tag.table_name}.*, #{ActsAsTaggableOn::Tagging.table_name}.tags_count AS count").order(options[:order]).limit(options[:limit])
@@ -106,7 +103,7 @@ module ActsAsTaggableOn::Taggable
         # Joins and conditions
         tagging_scope = tagging_scope.joins(taggable_join)
         tagging_conditions(options).each { |condition| tagging_scope = tagging_scope.where(condition) }
-        tag_scope     = tag_scope.where(options[:conditions])
+        tag_scope = tag_scope.where(options[:conditions])
 
         # GROUP BY and HAVING clauses:
         having = ["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) > 0"]
@@ -118,8 +115,7 @@ module ActsAsTaggableOn::Taggable
 
         unless options[:id]
           # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
-          scoped_select = "#{table_name}.#{primary_key}"
-          tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{safe_to_sql(select(scoped_select))})")
+          tagging_scope = generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key)
         end
 
         tagging_scope = tagging_scope.group(group_columns).having(having)
@@ -128,21 +124,34 @@ module ActsAsTaggableOn::Taggable
       end
 
       def safe_to_sql(relation)
-        connection.respond_to?(:unprepared_statement) ? connection.unprepared_statement{relation.to_sql} : relation.to_sql
+        connection.respond_to?(:unprepared_statement) ? connection.unprepared_statement { relation.to_sql } : relation.to_sql
       end
 
       private
 
+      def generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key)
+        table_name_pkey = "#{table_name}.#{primary_key}"
+        if ActsAsTaggableOn::Utils.using_mysql?
+          # See https://github.com/mbleigh/acts-as-taggable-on/pull/457 for details
+          scoped_ids = select(table_name_pkey).map(&:id)
+          tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN (?)", scoped_ids)
+        else
+          tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{safe_to_sql(select(table_name_pkey))})")
+        end
+
+        tagging_scope
+      end
+
       def tagging_conditions(options)
         tagging_conditions = []
-        tagging_conditions.push sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
+        tagging_conditions.push sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(: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(["#{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]
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = ?", options[:id]]) if options[:id]
 
-        tagging_conditions.push     taggable_conditions
+        tagging_conditions.push taggable_conditions
 
         tagging_conditions
       end
@@ -154,13 +163,13 @@ module ActsAsTaggableOn::Taggable
     end
 
     def tag_counts_on(context, options={})
-      self.class.tag_counts_on(context, options.merge(:id => id))
+      self.class.tag_counts_on(context, options.merge(id: id))
     end
 
     module CalculationMethods
-      def count
+      def count(column_name=:all)
         # https://github.com/rails/rails/commit/da9b5d4a8435b744fcf278fffd6d7f1e36d4a4f2
-        super(:all)
+        super
       end
     end
   end

data/lib/acts_as_taggable_on/acts_as_taggable_on/compatibility.rb

@@ -1,26 +1,27 @@
 module ActsAsTaggableOn::Compatibility
-  def has_many_with_compatibility(name, options = {}, &extention)
-    if ActiveRecord::VERSION::MAJOR >= 4
-      scope, opts = build_scope_and_options(options)
+  def has_many_with_taggable_compatibility(name, options = {}, &extention)
+    if ActsAsTaggableOn::Utils.active_record4?
+      scope, opts = build_taggable_scope_and_options(options)
       has_many(name, scope, opts, &extention)
     else
       has_many(name, options, &extention)
     end
   end
 
-  def build_scope_and_options(opts)
-    scope_opts, opts = parse_options(opts)
+  def build_taggable_scope_and_options(opts)
+    scope_opts, opts = parse_taggable_options(opts)
 
     unless scope_opts.empty?
-      scope = lambda do
-        scope_opts.inject(self) { |result, hash| result.send *hash }
-      end
+      scope = -> {
+        scope_opts.inject(self) { |result, hash| result.send(*hash) }
+      }
+      return [scope, opts]
     end
 
-    [defined?(scope) ? scope : nil, opts]
+    [nil, opts]
   end
 
-  def parse_options(opts)
+  def parse_taggable_options(opts)
     scope_opts = {}
     [:order, :having, :select, :group, :limit, :offset, :readonly].each do |o|
       scope_opts[o] = opts.delete o if opts[o]

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -12,29 +12,28 @@ module ActsAsTaggableOn::Taggable
     end
 
     module ClassMethods
-
       def initialize_acts_as_taggable_on_core
         include taggable_mixin
         tag_types.map(&:to_s).each do |tags_type|
-          tag_type         = tags_type.to_s.singularize
+          tag_type = tags_type.to_s.singularize
           context_taggings = "#{tag_type}_taggings".to_sym
-          context_tags     = tags_type.to_sym
-          taggings_order   = (preserve_tag_order? ? "#{ActsAsTaggableOn::Tagging.table_name}.id" : [])
+          context_tags = tags_type.to_sym
+          taggings_order = (preserve_tag_order? ? "#{ActsAsTaggableOn::Tagging.table_name}.id" : [])
 
           class_eval do
             # 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_compatibility context_taggings, :as => :taggable,
-                                        :dependent => :destroy,
-                                        :class_name => "ActsAsTaggableOn::Tagging",
-                                        :order => taggings_order,
-                                        :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.context = (?)", tags_type],
-                                        :include => :tag
-
-            has_many_with_compatibility context_tags, :through => context_taggings,
-                                        :source => :tag,
-                                        :class_name => "ActsAsTaggableOn::Tag",
-                                        :order => taggings_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
+
+            has_many_with_taggable_compatibility context_tags, through: context_taggings,
+                                                               source: :tag,
+                                                               class_name: 'ActsAsTaggableOn::Tag',
+                                                               order: taggings_order
 
           end
 
@@ -61,7 +60,7 @@ module ActsAsTaggableOn::Taggable
 
       # all column names are necessary for PostgreSQL group clause
       def grouped_column_names_for(object)
-        object.column_names.map { |column| "#{object.table_name}.#{column}" }.join(", ")
+        object.column_names.map { |column| "#{object.table_name}.#{column}" }.join(', ')
       end
 
       ##
@@ -84,7 +83,7 @@ module ActsAsTaggableOn::Taggable
       #   User.tagged_with("awesome", "cool", :owned_by => foo ) # Users that are tagged with just awesome and cool by 'foo'
       def tagged_with(tags, options = {})
         tag_list = ActsAsTaggableOn::TagList.from(tags)
-        empty_result = where("1 = 0")
+        empty_result = where('1 = 0')
 
         return empty_result if tag_list.empty?
 
@@ -96,33 +95,33 @@ module ActsAsTaggableOn::Taggable
 
         context = options.delete(:on)
         owned_by = options.delete(:owned_by)
-        alias_base_name = undecorated_table_name.gsub('.','_')
-        quote = ActsAsTaggableOn::Tag.using_postgresql? ? '"' : ''
+        alias_base_name = undecorated_table_name.gsub('.', '_')
+        quote = ActsAsTaggableOn::Utils.using_postgresql? ? '"' : ''
 
         if options.delete(:exclude)
           if options.delete(:wild)
-            tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name #{like_operator} ? ESCAPE '!'", "%#{escape_like(t)}%"]) }.join(" OR ")
+            tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'", "%#{ActsAsTaggableOn::Utils.escape_like(t)}%"]) }.join(' OR ')
           else
-            tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name #{like_operator} ?", t]) }.join(" OR ")
+            tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name #{ActsAsTaggableOn::Utils.like_operator} ?", t]) }.join(' OR ')
           end
 
           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)}"
           end
 
         elsif 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)
-          else
-            ActsAsTaggableOn::Tag.named_any(tag_list)
-          end
+                   ActsAsTaggableOn::Tag.named_like_any(tag_list)
+                 else
+                   ActsAsTaggableOn::Tag.named_any(tag_list)
+                 end
 
           return empty_result unless tags.length > 0
 
@@ -130,29 +129,30 @@ module ActsAsTaggableOn::Taggable
           # avoid ambiguous column name
           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('_'))}"
+          taggings_alias = adjust_taggings_alias(
+              "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{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}.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 ")
+          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?
 
           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
-                  ])
+            tagging_join << ' AND ' +
+                sanitize_sql([
+                  "#{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}"
         else
           tags = ActsAsTaggableOn::Tag.named_any(tag_list)
 
@@ -160,42 +160,42 @@ module ActsAsTaggableOn::Taggable
 
           tags.each do |tag|
             taggings_alias = adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{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 = "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}.context = ?", context.to_s]) if context
 
             if owned_by
-                tagging_join << " AND " +
+              tagging_join << ' AND ' +
                   sanitize_sql([
                     "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
                     owned_by.id,
                     owned_by.class.base_class.to_s
-                  ])
+                               ])
             end
 
             joins << tagging_join
           end
         end
 
-        group = [] # Rails interprets this as a no-op in the group() call below
+        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_columns = ActsAsTaggableOn::Utils.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
           group = group_columns
           order_by << "#{taggings_alias}_count DESC"
 
         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 << "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
+          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_columns = ActsAsTaggableOn::Utils.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
           group = group_columns
           having = "COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
         end
@@ -203,14 +203,12 @@ 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)
-
-        ((context and tag_types.one?) && options.delete(:any)) ? request : request.uniq
+            joins(joins.join(' ')).
+            where(conditions.join(' AND ')).
+            group(group).
+            having(having).
+            order(order_by.join(', ')).
+            readonly(false)
       end
 
       def is_taggable?
@@ -252,7 +250,7 @@ module ActsAsTaggableOn::Taggable
 
     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?
+      instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
     end
 
     def tag_list_cache_on(context)
@@ -283,10 +281,10 @@ module ActsAsTaggableOn::Taggable
     def all_tags_on(context)
       tagging_table_name = ActsAsTaggableOn::Tagging.table_name
 
-      opts  =  ["#{tagging_table_name}.context = ?", context.to_s]
+      opts = ["#{tagging_table_name}.context = ?", context.to_s]
       scope = base_tags.where(opts)
 
-      if ActsAsTaggableOn::Tag.using_postgresql?
+      if ActsAsTaggableOn::Utils.using_postgresql?
         group_columns = grouped_column_names_for(ActsAsTaggableOn::Tag)
         scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
       else
@@ -317,17 +315,17 @@ module ActsAsTaggableOn::Taggable
       custom_contexts + self.class.tag_types.map(&:to_s)
     end
 
-    def process_dirty_object(context,new_list)
+    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)
+        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)
+        changed_attributes[attrib] = old if old.to_s != value.to_s
       end
     end
 
@@ -353,7 +351,7 @@ module ActsAsTaggableOn::Taggable
         tag_list = tag_list_cache_on(context).uniq
 
         # Find existing tags or create non-existing tags:
-        tags = load_tags(tag_list)
+        tags = find_or_create_tags_from_list_with_context(tag_list, context)
 
         # Tag objects for currently assigned tags
         current_tags = tags_on(context)
@@ -382,23 +380,43 @@ module ActsAsTaggableOn::Taggable
           new_tags = tags - current_tags
         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
-
         # Destroy old taggings:
-        if old_taggings.present?
-          ActsAsTaggableOn::Tagging.destroy_all "#{ActsAsTaggableOn::Tagging.primary_key}".to_sym => old_taggings.map(&:id)
+        if old_tags.present?
+          ActsAsTaggableOn::Tagging.destroy_all(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)
+          taggings.create!(tag_id: tag.id, context: context.to_s, taggable: self)
         end
       end
 
       true
     end
+
+    private
+
+    ##
+    # Override this hook if you wish to subclass {ActsAsTaggableOn::Tag} --
+    # context is provided so that you may conditionally use a Tag subclass
+    # only for some contexts.
+    #
+    # @example Custom Tag class for one context
+    #   class Company < ActiveRecord::Base
+    #     acts_as_taggable_on :markets, :locations
+    #
+    #     def find_or_create_tags_from_list_with_context(tag_list, context)
+    #       if context.to_sym == :markets
+    #         MarketTag.find_or_create_all_with_like_by_name(tag_list)
+    #       else
+    #         super
+    #       end
+    #     end
+    #
+    # @param [Array<String>] tag_list Tags to find or create
+    # @param [Symbol] context The tag context for the tag_list
+    def find_or_create_tags_from_list_with_context(tag_list, _context)
+      load_tags(tag_list)
+    end
   end
 end