Recipe 14.5. Simplifying Folksonomy with the acts_as_taggable

Problem

You want to make it easier to assign tags to your content and then to search for records by their tags. You may also have more than one model in your application that you want to associate with tags.

Solution

Install and modify the acts_as_taggable plug-in, especially if you have more than one model that needs tagging. The plug-in ships with a broken instance method definition, but it can easily be modified to work as advertised. Start by downloading and installing the plug-in into your application:

$ ruby script/plugin install acts_as_taggable

The tag_list instance method needs to be defined as follows for it to work correctly. The tag_with method has also been customized to behave more naturally when assigning tags to objects.

vendor/plugins/acts_as_taggable/lib/acts_as_taggable.rb:

module ActiveRecord   module Acts #:nodoc:     module Taggable #:nodoc:       def self.included(base)         base.extend(ClassMethods)         end              module ClassMethods         def acts_as_taggable(options = {})           write_inheritable_attribute(:acts_as_taggable_options, {             :taggable_type => ActiveRecord::Base.\                     send(:class_name_of_active_record_descendant, self).to_s,             :from => options[:from]           })                      class_inheritable_reader :acts_as_taggable_options           has_many :taggings, :as => :taggable, :dependent => true           has_many :tags, :through => :taggings           include ActiveRecord::Acts::Taggable::InstanceMethods           extend ActiveRecord::Acts::Taggable::SingletonMethods                   end       end              module SingletonMethods         def find_tagged_with(list)           find_by_sql([             "SELECT #{table_name}.* FROM #{table_name}, tags, taggings " +             "WHERE #{table_name}.#{primary_key} = taggings.taggable_id " +             "AND taggings.taggable_type = ? " +             "AND taggings.tag_id = tags.id AND tags.name IN (?)",             acts_as_taggable_options[:taggable_type], list           ])         end       end              module InstanceMethods         def tag_with(list)           Tag.transaction do             curr_tags = self.tag_list             taggings.destroy_all             uniq_tags = (list + ' ' + curr_tags).split(/\s+/).uniq.join(" ")             Tag.parse(uniq_tags).sort.each do |name|               if acts_as_taggable_options[:from]                 send(acts_as_taggable_options[:from]).tags.\                                 find_or_create_by_name(name).on(self)               else                 Tag.find_or_create_by_name(name).on(self)               end             end           end         end         def tag_list           self.reload           tags.collect do |tag|             tag.name.include?(" ") ? "'#{tag.name}'" : tag.name           end.join(" ")         end       end     end   end end

Your application contains articles and announcements. You want the ability to tag objects from both models. Start by creating a migration to build these tables:

db/migrate/001_add_articles_add_announcements.rb:

class AddArticles < ActiveRecord::Migration   def self.up     create_table :articles do |t|       t.column :title, :text       t.column :body, :text       t.column :created_on, :date       t.column :updated_on, :date     end     create_table :announcements do |t|       t.column :body, :text       t.column :created_on, :date       t.column :updated_on, :date     end   end   def self.down     drop_table :articles     drop_table :announcements   end end

Next, generate a migration to set up the necessary tags and taggings tables, as required by the plug-in.

db/migrate/002_add_tag_support.rb:

class AddTagSupport < ActiveRecord::Migration   def self.up     # Table for your Tags     create_table :tags do |t|       t.column :name, :string     end     create_table :taggings do |t|       t.column :tag_id, :integer       # id of tagged object       t.column :taggable_id, :integer       # type of object tagged       t.column :taggable_type, :string     end   end   def self.down     drop_table :tags     drop_table :taggings   end end

Finally, in article.rb and announcement.rb, declare both the Article and Announcement models as taggable:

app/models/article.rb:

class Article < ActiveRecord::Base   acts_as_taggable end

app/models/announcement.rb:

class Announcement < ActiveRecord::Base   acts_as_taggable end

You can now use the tag_with method provided by the plug-in to associate tags with both Article and Announcement objects. You can view the assigned tags of an object with the tag_list method.

Once you have some content associated with tags, you can use those tags to help users search for relevant content. Use find_tagged_with to find all articles tagged with "indispensable", for example:

Article.find_tagged_with("indispensable")

This returns an array of objects associated with that tag. There's no method to find all object types by tag name but there's no reason you couldn't add such a method to the Tag class.

Discussion

To demonstrate how to use this plug-in, create some fixtures, and load them into your database with rake db:fixtures:load:

test/fixtures/articles.yml:

first:   id: 1   title: Vim 7.0 Released!   body: Vim 7 adds native spell checking, tabs and the app... another:   id: 2   title: Foo Camp   body: The bar at Foo Camp is appropriately named Foo Bar... third:   id: 3   title: Web 4.0    body: Time to refactor...

test/fixtures/announcements.yml:

first:   id: 1   body: Classes will start in November. second:   id: 2   body: There will be a concert at noon in the quad.

Now, open a Rails console session and instantiate an Article object. Assign a few tags with tag_with, then list them with tag_list. Next, add an additional tag with tag_with. Now, tag_list shows all four tags. This behaviorappending new tags to the listis the result of our modified version of tag_with. The unmodified version removes existing tags whenever you add new ones.

$ ./script/console  Loading development environment. >> article = Article.find(1) => #<Article:0x25909f4 @attributes={"created_on"=>nil,  "body"=>"Vim 7 adds native spell checking, tabs and the app...",  "title"=>"Vim 7.0 Released!", "updated_on"=>nil, "id"=>"1"}> >> article.tag_with('editor bram uganda')    => ["bram", "editor", "uganda"] >> article.tag_list => "bram editor uganda" >> article.tag_with('productivity') => ["bram", "editor", "productivity", "uganda"] >> article.tag_list => "bram editor uganda productivity"

Now create an Announcement object, and assign it a couple of tags:

>> announcement = Announcement.find(1) => #<Announcement:0x25054a8 @attributes={"created_on"=>nil,  "body"=>"Classes will start in November.", "updated_on"=>nil, "id"=>"1"}> >> announcement.tag_with('important schedule') => ["important", "schedule"] >> announcement.tag_list => "important schedule"

The plug-in allows you to assign tags to any number of models as long as they are declared as taggable (as in the solution with acts_as_taggable in the model class definitions). This is due to a polymorphic association with the taggable interface as set up by the following lines of the acts_as_taggable class method in acts_as_taggable.rb:

def acts_as_taggable(options = {})   write_inheritable_attribute(:acts_as_taggable_options, {     :taggable_type => ActiveRecord::Base.\             send(:class_name_of_active_record_descendant, self).to_s,     :from => options[:from]   })      class_inheritable_reader :acts_as_taggable_options   has_many :taggings, :as => :taggable, :dependent => true   has_many :tags, :through => :taggings   include ActiveRecord::Acts::Taggable::InstanceMethods   extend ActiveRecord::Acts::Taggable::SingletonMethods           end

...along with the corresponding association method calls in the tagging.rb and tag.rb:

class Tagging < ActiveRecord::Base   belongs_to :tag   belongs_to :taggable, :polymorphic => true   ... end

class Tag < ActiveRecord::Base   has_many :taggings   ... end

The taggings table stores all the associations between tags and objects being tagged. The taggable_id and taggable_type columns differentiate between the different object type associations. Here is the contents of this table after we've assigned tags to Article and Announcement objects:

mysql> select * from taggings; +----+--------+-------------+---------------+ | id | tag_id | taggable_id | taggable_type | +----+--------+-------------+---------------+ |  4 |      1 |           1 | Article       |  |  5 |      2 |           1 | Article       |  |  6 |      4 |           1 | Article       |  |  7 |      3 |           1 | Article       |  |  8 |      5 |           1 | Announcement  |  |  9 |      6 |           1 | Announcement  |  +----+--------+-------------+---------------+

The specific modifications made to the plug-in's default instance methods include fixing what looks to be a typo in tag_list, but also adding the call to self.reload in that method. Calling self.reload allows you to view all current tags on an object with tag_list immediately after adding more tags with tag_with. The other significant addition is to the tag_with method. The method has been altered to save all current tags, then destroy all taggings with taggings.destroy_all, and finally to create a new list of taggings that merges the existing taggings with those being added as parameters. The end result is that tag_with now has a cumulative effect when tags are added.

Recipe 14.5. Simplifying Folksonomy with the acts_as_taggable

Problem

Solution

Discussion

See Also