hervalicio.us » Caching things with acts_as_taggable_on

RSS Feeds

Me

Pet Projects

Posted on May 25, 2007 at 8:25 pm

Caching things with acts_as_taggable_on_steroids

On today’s chapter of “hacking the hell out of rails plugins” we’re going to talk about how to add caching support for acts_as_taggable_on_steroids.
The plugin is a great improvement over the original (and discontinued) acts_as_taggable, and allow you to add “tagging” support to any model class easily, just by marking it with “acts_as_taggable”:

You will soon notice, however, that your system grows, rubber ducks will get slower and slower to manipulate - specially when you want to list, say, rubber ducks and their related tags, or the number of tags associated to each rubber duck. That is due to the fact that acts_as_taggable doesn’t cache any information on the taggable class (in our case, the glorious rubber ducks).
But don’t panic - addind that support is easy as 1, 2, 3. The code below is from my modified acts_as_taggable.rb, which now supports caching both number of tags per duck, or a cached list of tags:

module ActiveRecord
  module Acts #:nodoc:
    module Taggable #:nodoc:
      def self.included(base)
        base.extend(ClassMethods)
      end

module ClassMethods
        def acts_as_taggable(options = {})
          @@cache_tags = options[:cache_tags] || nil
          @@cache_tag_count = options[:cache_tag_count] || nil

has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag
          has_many :tags, :through => :taggings

before_save :save_caches
          after_save :save_tags

def self.cache_tags
            @@cache_tags
          end
          def self.cache_tag_count
            @@cache_tag_count
          end

include ActiveRecord::Acts::Taggable::InstanceMethods
          extend ActiveRecord::Acts::Taggable::SingletonMethods

alias_method :reload_without_tag_list, :reload
          alias_method :reload, :reload_with_tag_list
        end
      end

module SingletonMethods
        # Pass either a tag string, or an array of strings or tags
        #
        # Options:
        #   :exclude - Find models that are not tagged with the given tags
        #   :match_all - Find models that match all of the gievn tags, not just one
        #   :conditions - A piece of SQL conditions to add to the query
        def find_tagged_with(tags, options = {})
          tags = Tag.parse(tags) if tags.is_a?(String)
          return [] if tags.empty?
          tags.map!(&:to_s)

conditions = sanitize_sql(["#{table_name}_tags.name #{"NOT" if options.delete(:exclude)} IN (?)", tags])
          conditions << " AND #{sanitize_sql(options.delete(:conditions))}" if options[:conditions]

group = "#{table_name}_taggings.taggable_id HAVING COUNT(#{table_name}_taggings.taggable_id) = #{tags.size}" if options.delete(:match_all)

find(:all, { :select => "DISTINCT #{table_name}.*",
            :joins => "LEFT OUTER JOIN taggings #{table_name}_taggings ON #{table_name}_taggings.taggable_id = #{table_name}.#{primary_key} AND #{table_name}_taggings.taggable_type = '#{name}' " +
                      "LEFT OUTER JOIN tags #{table_name}_tags ON #{table_name}_tags.id = #{table_name}_taggings.tag_id",
            :conditions => conditions,
            :group      => group }.merge(options))
        end

# Options:
        #  :start_at - Restrict the tags to those created after a certain time
        #  :end_at - Restrict the tags to those created before a certain time
        #  :conditions - A piece of SQL conditions to add to the query
        #  :limit - The maximum number of tags to return
        #  :order - A piece of SQL to order by. Eg 'tags.count desc' or 'taggings.created_at desc'
        #  :at_least - Exclude tags with a frequency less than the given value
        #  :at_most - Exclude tags with a frequency greater then the given value
        def tag_counts(options = {})
          options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit

scope = scope(:find)
          start_at = sanitize_sql(['taggings.created_at >= ?', options[:start_at]]) if options[:start_at]
          end_at = sanitize_sql(['taggings.created_at <= ?', options[:end_at]]) if options[:end_at]

conditions = [
            "taggings.taggable_type = '#{name}'",
            options[:conditions],
            scope && scope[:conditions],
            start_at,
            end_at
          ]
          conditions = conditions.compact.join(' and ')

at_least  = sanitize_sql(['count >= ?', options[:at_least]]) if options[:at_least]
          at_most   = sanitize_sql(['count <= ?', options[:at_most]]) if options[:at_most]
          having    = [at_least, at_most].compact.join(' and ')
          group_by  = 'tags.id, tags.name having count(*) > 0'
          group_by << " and #{having}" unless having.blank?

Tag.find(:all,
            :select     => 'tags.id, tags.name, COUNT(*) AS count',
            :joins      => "LEFT OUTER JOIN taggings ON tags.id = taggings.tag_id LEFT OUTER JOIN #{table_name} ON #{table_name}.#{primary_key} = taggings.taggable_id",
            :conditions => conditions,
            :group      => group_by,
            :order      => options[:order],
            :limit      => options[:limit]
          )
        end
      end

module InstanceMethods
        attr_writer :tag_list

def tag_list
          defined?(@tag_list) ? @tag_list : read_tags
        end

def save_caches
          if defined?(@tag_list)
            if self.class.cache_tags || self.class.cache_tag_count
              if @tag_list.nil?
                tags = []
              else
                tags = @tag_list.split(Tag.delimiter).collect { |tag| tag.strip }.uniq.sort
              end

write_attribute(self.class.cache_tags, tags.join(Tag.delimiter)) if self.class.cache_tags
              write_attribute(self.class.cache_tag_count, tags.size) if self.class.cache_tag_count
            end
          end
        end

def save_tags
          if defined?(@tag_list)
            write_tags(@tag_list)
            remove_tag_list
          end
        end

def write_tags(list)
          new_tag_names = Tag.parse(list).uniq
          old_tagging_ids = []

Tag.transaction do
            taggings.each do |tagging|
              index = new_tag_names.index(tagging.tag.name)
              index ? new_tag_names.delete_at(index) : old_tagging_ids << tagging.id
            end

Tagging.delete_all(['id in (?)', old_tagging_ids]) if old_tagging_ids.any?

# Create any new tags/taggings
            new_tag_names.each do |name|
              Tag.find_or_create_by_name(name).tag(self)
            end

taggings.reset
            tags.reset
          end
          true
        end

def read_tags
          tags.map do |tag|
            tag.name.include?(Tag.delimiter) ? ""#{tag.name}"" : tag.name
          end.join(Tag.delimiter.ends_with?(" ") ? Tag.delimiter : "#{Tag.delimiter} ")
        end

def reload_with_tag_list(*args)
          remove_tag_list
          reload_without_tag_list(*args)
        end

private
        def remove_tag_list
          remove_instance_variable(:@tag_list) if defined?(@tag_list)
        end
      end
    end
  end
end

ActiveRecord::Base.send(:include, ActiveRecord::Acts::Taggable)

The main addition here, as you can see, is basically the save_caches() instance method and two class-level variables (@@cache_tags and @@cache_tag_count), that will handle caching of tag count and tags on the taggable class. Making rubber ducks cache is simple:

And there you go: rubber ducks that keep both tag count and list of tags on the rubber_ducks table, with no need to join to the tags/taggings. By the way, don’t forget to add the two fields to your rubber_ducks table.
Obviously, some improvements can be done (you can call the cache attribute tag_list, for instance - but then you’d need to modify methods such as the remote_tag_list, which I really didn’t bother modifying).
Have fun!

Tags:plugins, rails, ruby

by herval
Posts in English

2 Responses to “Caching things with acts_as_taggable_on_steroids”

fulvio on February 2nd, 2008 at 2:46 am says:

Hmm, thanks for this!

However, I get the following error:

undefined method `delimiter’ for Tag:Class
fulvio on February 2nd, 2008 at 2:53 am says:

If I replace all instances of Tag.delimiter with “,” (which is what I specified in my environment.rb by doing TagList.delimiter = “,”) it works.

However it then throws the following error:

undefined method `parse’ for Tag:Class

About

… I won’t be laughing at the lies when I’m gone And I can’t question how or when or why when I’m gone Can’t live proud enough to die when I’m gone So I guess I’ll have to do it when I’m here.