acts-as-taggable-on 4.0.0.pre → 7.0.0

data/gemfiles/activerecord_5.2.gemfile

@@ -0,0 +1,21 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.2.0"
+case ENV["DB"]
+when "postgresql"
+  gem 'pg'
+when "mysql"
+  gem 'mysql2', '~> 0.3'
+else
+  gem "sqlite3", "~> 1.3", "< 1.4"
+end
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+  gem "byebug", platforms: [:mri]
+end
+
+gemspec path: "../"

data/gemfiles/activerecord_6.0.gemfile

@@ -0,0 +1,21 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 6.0.0"
+case ENV["DB"]
+when "postgresql"
+  gem 'pg'
+when "mysql"
+  gem 'mysql2', '~> 0.4'
+else
+  gem 'sqlite3'
+end
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+  gem "byebug", platforms: [:mri]
+end
+
+gemspec path: "../"

data/gemfiles/activerecord_6.1.gemfile

@@ -0,0 +1,23 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 6.1.0"
+case ENV["DB"]
+when "postgresql"
+  gem 'pg'
+when "mysql"
+  gem 'mysql2', '~> 0.5'
+else
+  gem 'sqlite3'
+end
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+  gem "byebug", platforms: [:mri]
+end
+
+gemspec path: "../"

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

@@ -31,6 +31,7 @@ module ActsAsTaggableOn
     autoload :Dirty
     autoload :Ownership
     autoload :Related
+    autoload :TagListType
   end
 
   autoload :Utils
@@ -57,13 +58,14 @@ module ActsAsTaggableOn
   def self.glue
     setting = @configuration.delimiter
     delimiter = setting.kind_of?(Array) ? setting[0] : setting
-    delimiter.ends_with?(' ') ? delimiter : "#{delimiter} "
+    delimiter.end_with?(' ') ? delimiter : "#{delimiter} "
   end
 
   class Configuration
     attr_accessor :force_lowercase, :force_parameterize,
                   :remove_unused_tags, :default_parser,
-                  :tags_counter
+                  :tags_counter, :tags_table,
+                  :taggings_table
     attr_reader :delimiter, :strict_case_match
 
     def initialize
@@ -75,6 +77,8 @@ module ActsAsTaggableOn
       @tags_counter = true
       @default_parser = DefaultParser
       @force_binary_collation = false
+      @tags_table = :tags
+      @taggings_table = :taggings
     end
 
     def strict_case_match=(force_cs)

data/lib/acts_as_taggable_on/tag.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
+    self.table_name = ActsAsTaggableOn.tags_table
 
     ### ASSOCIATIONS:
 
@@ -9,7 +10,7 @@ module ActsAsTaggableOn
     ### VALIDATIONS:
 
     validates_presence_of :name
-    validates_uniqueness_of :name, if: :validates_name_uniqueness?
+    validates_uniqueness_of :name, if: :validates_name_uniqueness?, case_sensitive: true
     validates_length_of :name, maximum: 255
 
     # monkey patch this method if don't need name uniqueness validation
@@ -50,8 +51,8 @@ module ActsAsTaggableOn
 
     def self.for_context(context)
       joins(:taggings).
-        where(["taggings.context = ?", context]).
-        select("DISTINCT tags.*")
+        where(["#{ActsAsTaggableOn.taggings_table}.context = ?", context]).
+        select("DISTINCT #{ActsAsTaggableOn.tags_table}.*")
     end
 
     ### CLASS METHODS:
@@ -70,16 +71,19 @@ module ActsAsTaggableOn
       return [] if list.empty?
 
       existing_tags = named_any(list)
-
       list.map do |tag_name|
-        comparable_tag_name = comparable_name(tag_name)
-        existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
         begin
+          tries ||= 3
+          comparable_tag_name = comparable_name(tag_name)
+          existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
           existing_tag || create(name: tag_name)
         rescue ActiveRecord::RecordNotUnique
-          # Postgres aborts the current transaction with
-          # PG::InFailedSqlTransaction: ERROR:  current transaction is aborted, commands ignored until end of transaction block
-          # so we have to rollback this transaction
+          if (tries -= 1).positive?
+            ActiveRecord::Base.connection.execute 'ROLLBACK'
+            existing_tags = named_any(list)
+            retry
+          end
+
           raise DuplicateTagError.new("'#{tag_name}' has already been taken")
         end
       end
@@ -101,8 +105,6 @@ module ActsAsTaggableOn
 
     class << self
 
-
-
       private
 
       def comparable_name(str)
@@ -117,20 +119,12 @@ module ActsAsTaggableOn
         ActsAsTaggableOn::Utils.using_mysql? ? 'BINARY ' : nil
       end
 
-      def unicode_downcase(string)
-        if ActiveSupport::Multibyte::Unicode.respond_to?(:downcase)
-          ActiveSupport::Multibyte::Unicode.downcase(string)
-        else
-          ActiveSupport::Multibyte::Chars.new(string).downcase.to_s
-        end
+      def as_8bit_ascii(string)
+        string.to_s.mb_chars
       end
 
-      def as_8bit_ascii(string)
-        if defined?(Encoding)
-          string.to_s.dup.force_encoding('BINARY')
-        else
-          string.to_s.mb_chars
-        end
+      def unicode_downcase(string)
+        as_8bit_ascii(string).downcase
       end
 
       def sanitize_sql_for_named_any(tag)

data/lib/acts_as_taggable_on/tag_list.rb

@@ -41,6 +41,7 @@ module ActsAsTaggableOn
     # Appends the elements of +other_tag_list+ to +self+.
     def concat(other_tag_list)
       super(other_tag_list).send(:clean!)
+      self
     end
 
     ##

data/lib/acts_as_taggable_on/taggable.rb

@@ -96,7 +96,6 @@ module ActsAsTaggableOn
       include Cache
       include Ownership
       include Related
-      include Dirty
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/cache.rb

@@ -3,47 +3,51 @@ module ActsAsTaggableOn::Taggable
     def self.included(base)
       # When included, conditionally adds tag caching methods when the model
       #   has any "cached_#{tag_type}_list" column
-      base.instance_eval do
-        # @private
-        def _has_tags_cache_columns?(db_columns)
-          db_column_names = db_columns.map(&:name)
-          tag_types.any? do |context|
-            db_column_names.include?("cached_#{context.to_s.singularize}_list")
-          end
+      base.extend Columns
+    end
+
+    module Columns
+      # ActiveRecord::Base.columns makes a database connection and caches the
+      #   calculated columns hash for the record as @columns.  Since we don't
+      #   want to add caching methods until we confirm the presence of a
+      #   caching column, and we don't want to force opening a database
+      #   connection when the class is loaded, here we intercept and cache
+      #   the call to :columns as @acts_as_taggable_on_cache_columns
+      #   to mimic the underlying behavior.  While processing this first
+      #   call to columns, we do the caching column check and dynamically add
+      #   the class and instance methods
+      #   FIXME: this method cannot compile in rubinius
+      def columns
+        @acts_as_taggable_on_cache_columns ||= begin
+          db_columns = super
+          _add_tags_caching_methods if _has_tags_cache_columns?(db_columns)
+          db_columns
         end
+      end
 
-        # @private
-        def _add_tags_caching_methods
-          send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
-          extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
+      def reset_column_information
+        super
+        @acts_as_taggable_on_cache_columns = nil
+      end
 
-          before_save :save_cached_tag_list
+      private
 
-          initialize_tags_cache
+      # @private
+      def _has_tags_cache_columns?(db_columns)
+        db_column_names = db_columns.map(&:name)
+        tag_types.any? do |context|
+          db_column_names.include?("cached_#{context.to_s.singularize}_list")
         end
+      end
 
-        # ActiveRecord::Base.columns makes a database connection and caches the
-        #   calculated columns hash for the record as @columns.  Since we don't
-        #   want to add caching methods until we confirm the presence of a
-        #   caching column, and we don't want to force opening a database
-        #   connection when the class is loaded, here we intercept and cache
-        #   the call to :columns as @acts_as_taggable_on_cache_columns
-        #   to mimic the underlying behavior.  While processing this first
-        #   call to columns, we do the caching column check and dynamically add
-        #   the class and instance methods
-        #   FIXME: this method cannot compile in rubinius
-        def columns
-          @acts_as_taggable_on_cache_columns ||= begin
-            db_columns = super
-            _add_tags_caching_methods if _has_tags_cache_columns?(db_columns)
-            db_columns
-          end
-        end
+      # @private
+      def _add_tags_caching_methods
+        send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
+        extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
 
-        def reset_column_information
-          super
-          @acts_as_taggable_on_cache_columns = nil
-        end
+        before_save :save_cached_tag_list
+
+        initialize_tags_cache
       end
     end
 

data/lib/acts_as_taggable_on/taggable/collection.rb

@@ -94,16 +94,18 @@ module ActsAsTaggableOn::Taggable
         ## Generate conditions:
         options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
 
-        ## Generate joins:
-        taggable_join = "INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id"
-        taggable_join << " AND #{table_name}.#{inheritance_column} = '#{name}'" unless descends_from_active_record? # Current model is STI descendant, so add type checking to the join condition
-
         ## Generate scope:
         tagging_scope = ActsAsTaggableOn::Tagging.select("#{ActsAsTaggableOn::Tagging.table_name}.tag_id, COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) AS tags_count")
         tag_scope = ActsAsTaggableOn::Tag.select("#{ActsAsTaggableOn::Tag.table_name}.*, #{ActsAsTaggableOn::Tagging.table_name}.tags_count AS count").order(options[:order]).limit(options[:limit])
 
-        # Joins and conditions
-        tagging_scope = tagging_scope.joins(taggable_join)
+        # Current model is STI descendant, so add type checking to the join condition
+        unless descends_from_active_record?
+          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}'"
+          tagging_scope = tagging_scope.joins(taggable_join)
+        end
+
+        # Conditions
         tagging_conditions(options).each { |condition| tagging_scope = tagging_scope.where(condition) }
         tag_scope = tag_scope.where(options[:conditions])
 
@@ -174,7 +176,7 @@ module ActsAsTaggableOn::Taggable
       # See https://github.com/rails/rails/blob/master/activerecord/lib/active_record/relation/calculations.rb#L38
       def count(column_name = :all, options = {})
         # https://github.com/rails/rails/commit/da9b5d4a8435b744fcf278fffd6d7f1e36d4a4f2
-        ActsAsTaggableOn::Utils.active_record5? ? super(column_name) : super(column_name, options)
+        super(column_name)
       end
     end
   end

data/lib/acts_as_taggable_on/taggable/core.rb

@@ -1,5 +1,9 @@
+require_relative 'tagged_with_query'
+require_relative 'tag_list_type'
+
 module ActsAsTaggableOn::Taggable
   module Core
+
     def self.included(base)
       base.extend ActsAsTaggableOn::Taggable::Core::ClassMethods
 
@@ -25,13 +29,17 @@ module ActsAsTaggableOn::Taggable
             # the associations tag_taggings & tags are always returned in created order
             has_many context_taggings, -> { includes(:tag).order(taggings_order).where(context: tags_type) },
                      as: :taggable,
-                     class_name: ActsAsTaggableOn::Tagging,
-                     dependent: :destroy
+                     class_name: 'ActsAsTaggableOn::Tagging',
+                     dependent: :destroy,
+                     after_add: :dirtify_tag_list,
+                     after_remove: :dirtify_tag_list
 
             has_many context_tags, -> { order(taggings_order) },
-                     class_name: ActsAsTaggableOn::Tag,
+                     class_name: 'ActsAsTaggableOn::Tag',
                      through: context_taggings,
                      source: :tag
+
+            attribute "#{tags_type.singularize}_list".to_sym, ActsAsTaggableOn::Taggable::TagListType.new
           end
 
           taggable_mixin.class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -40,12 +48,30 @@ module ActsAsTaggableOn::Taggable
             end
 
             def #{tag_type}_list=(new_tags)
+              parsed_new_list = ActsAsTaggableOn.default_parser.new(new_tags).parse
+
+              if self.class.preserve_tag_order? || (parsed_new_list.sort != #{tag_type}_list.sort)
+                if ActsAsTaggableOn::Utils.legacy_activerecord?
+                  set_attribute_was("#{tag_type}_list", #{tag_type}_list)
+                else
+                  unless #{tag_type}_list_changed?
+                    @attributes["#{tag_type}_list"] = ActiveModel::Attribute.from_user("#{tag_type}_list", #{tag_type}_list, ActsAsTaggableOn::Taggable::TagListType.new)
+                  end
+                end
+                write_attribute("#{tag_type}_list", parsed_new_list)
+              end
+
               set_tag_list_on('#{tags_type}', new_tags)
             end
 
             def all_#{tags_type}_list
               all_tags_list_on('#{tags_type}')
             end
+
+            private
+            def dirtify_tag_list(tagging)
+              attribute_will_change! tagging.context.singularize+"_list"
+            end
           RUBY
         end
       end
@@ -84,173 +110,19 @@ module ActsAsTaggableOn::Taggable
       def tagged_with(tags, options = {})
         tag_list = ActsAsTaggableOn.default_parser.new(tags).parse
         options = options.dup
-        empty_result = where('1 = 0')
-
-        return empty_result if tag_list.empty?
-
-        joins = []
-        conditions = []
-        having = []
-        select_clause = []
-        order_by = []
-
-        context = options.delete(:on)
-        owned_by = options.delete(:owned_by)
-        alias_base_name = undecorated_table_name.gsub('.', '_')
-        # FIXME use ActiveRecord's connection quote_column_name
-        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 #{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 #{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 << " 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 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)
-                 else
-                   ActsAsTaggableOn::Tag.named_any(tag_list)
-                 end
-
-          return empty_result if tags.length == 0
-
-          # setup taggings alias so we can chain, ex: items_locations_taggings_awesome_cool_123
-          # avoid ambiguous column name
-          taggings_context = context ? "_#{context}" : ''
-
-          taggings_alias = adjust_taggings_alias(
-              "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tags.map(&:name).join('_'))}"
-          )
-
-          tagging_cond = "#{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
-                          " WHERE #{taggings_alias}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
-                          " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name, nil)}"
-
-          tagging_cond << " AND " + sanitize_sql(["#{taggings_alias}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
-          tagging_cond << " AND " + sanitize_sql(["#{taggings_alias}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
-
-          tagging_cond << " 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
-          tag_ids = tags.map { |t| quote_value(t.id, nil) }.join(', ')
-          tagging_cond << " AND #{taggings_alias}.tag_id in (#{tag_ids})"
-          select_clause << " #{table_name}.*" unless context and tag_types.one?
-
-          if owned_by
-            tagging_cond << ' AND ' +
-                sanitize_sql([
-                                 "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
-                                 owned_by.id,
-                                 owned_by.class.base_class.to_s
-                             ])
-          end
-
-          conditions << "EXISTS (SELECT 1 FROM #{tagging_cond})"
-          if options.delete(:order_by_matching_tag_count)
-            order_by << "(SELECT count(*) FROM #{tagging_cond}) desc"
-          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_#{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}.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
-                               ])
-            end
 
-            joins << tagging_join
-          end
-        end
-
-        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::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 << " 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
-          having = "COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
-        end
-
-        order_by << options[:order] if options[:order].present?
+        return none if tag_list.empty?
 
-        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)
+        ::ActsAsTaggableOn::Taggable::TaggedWithQuery.build(self, ActsAsTaggableOn::Tag, ActsAsTaggableOn::Tagging, tag_list, options)
       end
 
       def is_taggable?
         true
       end
 
-      def adjust_taggings_alias(taggings_alias)
-        if taggings_alias.size > 75
-          taggings_alias = 'taggings_alias_' + Digest::SHA1.hexdigest(taggings_alias)
-        end
-        taggings_alias
-      end
-
       def taggable_mixin
         @taggable_mixin ||= Module.new
       end
-
-      private
-
-      # Rails 5 has merged sanitize and quote_value
-      # See https://github.com/rails/rails/blob/master/activerecord/lib/active_record/sanitization.rb#L10
-      def quote_value(value, column = nil)
-        ActsAsTaggableOn::Utils.active_record5? ? super(value) : super(value, column)
-      end
     end
 
     # all column names are necessary for PostgreSQL group clause
@@ -283,7 +155,7 @@ module ActsAsTaggableOn::Taggable
       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)
+      elsif cached_tag_list_on(context) && ensure_included_cache_methods! && self.class.caching_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)))
@@ -312,7 +184,7 @@ module ActsAsTaggableOn::Taggable
 
       if ActsAsTaggableOn::Utils.using_postgresql?
         group_columns = grouped_column_names_for(ActsAsTaggableOn::Tag)
-        scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
+        scope.order(Arel.sql("max(#{tagging_table_name}.created_at)")).group(group_columns)
       else
         scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
       end.to_a
@@ -332,33 +204,16 @@ module ActsAsTaggableOn::Taggable
       add_custom_context(context)
 
       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.default_parser.new(new_list).parse)
+      parsed_new_list = ActsAsTaggableOn.default_parser.new(new_list).parse
+
+      instance_variable_set(variable_name, parsed_new_list)
     end
 
     def tagging_contexts
       self.class.tag_types.map(&:to_s) + custom_contexts
     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)
-        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
-
     def reload(*args)
       self.class.tag_types.each do |context|
         instance_variable_set("@#{context.to_s.singularize}_list", nil)
@@ -426,6 +281,10 @@ module ActsAsTaggableOn::Taggable
 
     private
 
+    def ensure_included_cache_methods!
+      self.class.columns
+    end
+
     # 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"}
@@ -462,3 +321,4 @@ module ActsAsTaggableOn::Taggable
     end
   end
 end
+