acts-as-taggable-on 3.5.0 → 8.1.0

data/lib/acts_as_taggable_on/engine.rb

@@ -1,4 +1,3 @@
-require 'rails/engine'
 module ActsAsTaggableOn
   class Engine < Rails::Engine
   end

data/lib/acts_as_taggable_on/tag.rb

@@ -1,8 +1,7 @@
 # encoding: utf-8
 module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
-
-    attr_accessible :name if defined?(ActiveModel::MassAssignmentSecurity)
+    self.table_name = ActsAsTaggableOn.tags_table
 
     ### ASSOCIATIONS:
 
@@ -11,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,6 +49,18 @@ module ActsAsTaggableOn
       where(clause)
     end
 
+    def self.for_context(context)
+      joins(:taggings).
+        where(["#{ActsAsTaggableOn.taggings_table}.context = ?", context]).
+        select("DISTINCT #{ActsAsTaggableOn.tags_table}.*")
+    end
+
+    def self.for_tenant(tenant)
+      joins(:taggings).
+        where("#{ActsAsTaggableOn.taggings_table}.tenant = ?", tenant.to_s).
+        select("DISTINCT #{ActsAsTaggableOn.tags_table}.*")
+    end
+
     ### CLASS METHODS:
 
     def self.find_or_create_with_like_by_name(name)
@@ -66,16 +77,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
@@ -97,8 +111,6 @@ module ActsAsTaggableOn
 
     class << self
 
-
-
       private
 
       def comparable_name(str)
@@ -113,20 +125,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
 
     ##
@@ -84,7 +85,8 @@ module ActsAsTaggableOn
       map! { |tag| tag.mb_chars.downcase.to_s } if ActsAsTaggableOn.force_lowercase
       map!(&:parameterize) if ActsAsTaggableOn.force_parameterize
 
-      uniq!
+      ActsAsTaggableOn.strict_case_match ? uniq! : uniq!{ |tag| tag.downcase }
+      self
     end
 
 
@@ -99,18 +101,6 @@ module ActsAsTaggableOn
       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/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
 
@@ -73,7 +77,7 @@ module ActsAsTaggableOn::Taggable
         tag_types.map(&:to_s).each do |tag_type|
           if self.class.send("caching_#{tag_type.singularize}_list?")
             if tag_list_cache_set_on(tag_type)
-              list = tag_list_cache_on(tag_type).to_a.flatten.compact.join(', ')
+              list = tag_list_cache_on(tag_type).to_a.flatten.compact.join("#{ActsAsTaggableOn.delimiter} ")
               self["cached_#{tag_type.singularize}_list"] = list
             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])
 
@@ -138,7 +140,7 @@ module ActsAsTaggableOn::Taggable
           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))})")
+          tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{safe_to_sql(except(:select).select(table_name_pkey))})")
         end
 
         tagging_scope
@@ -169,9 +171,12 @@ module ActsAsTaggableOn::Taggable
     end
 
     module CalculationMethods
-      def count(column_name=:all, options = {})
+      # Rails 5 TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
+      # 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
-        super
+        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
 
@@ -23,18 +27,19 @@ module ActsAsTaggableOn::Taggable
           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_taggable_compatibility context_taggings, as: :taggable,
-                                                 dependent: :destroy,
-                                                 class_name: 'ActsAsTaggableOn::Tagging',
-                                                 order: taggings_order,
-                                                 conditions: {context: tags_type},
-                                                 include: :tag
-
-            has_many_with_taggable_compatibility context_tags, through: context_taggings,
-                                                 source: :tag,
-                                                 class_name: 'ActsAsTaggableOn::Tag',
-                                                 order: taggings_order
-
+            has_many context_taggings, -> { includes(:tag).order(taggings_order).where(context: tags_type) },
+                     as: :taggable,
+                     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',
+                     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
@@ -43,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
@@ -87,162 +110,16 @@ 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]
+        return none if tag_list.empty?
 
-            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?
-
-        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
@@ -254,7 +131,7 @@ module ActsAsTaggableOn::Taggable
     end
 
     def custom_contexts
-      @custom_contexts ||= []
+      @custom_contexts ||= taggings.map(&:context).uniq
     end
 
     def is_taggable?
@@ -278,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)))
@@ -307,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
@@ -327,30 +204,19 @@ 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
-      custom_contexts + self.class.tag_types.map(&:to_s)
+      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
+    def taggable_tenant
+      if self.class.tenant_column
+        public_send(self.class.tenant_column)
       end
     end
 
@@ -407,12 +273,16 @@ module ActsAsTaggableOn::Taggable
 
         # Destroy old taggings:
         if old_tags.present?
-          taggings.not_owned.by_context(context).destroy_all(tag_id: old_tags)
+          taggings.not_owned.by_context(context).where(tag_id: old_tags).destroy_all
         end
 
         # Create new taggings:
         new_tags.each do |tag|
-          taggings.create!(tag_id: tag.id, context: context.to_s, taggable: self)
+          if taggable_tenant
+            taggings.create!(tag_id: tag.id, context: context.to_s, taggable: self, tenant: taggable_tenant)
+          else
+            taggings.create!(tag_id: tag.id, context: context.to_s, taggable: self)
+          end
         end
       end
 
@@ -421,6 +291,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"}
@@ -432,7 +306,7 @@ module ActsAsTaggableOn::Taggable
       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
@@ -457,3 +331,4 @@ module ActsAsTaggableOn::Taggable
     end
   end
 end
+