acts-as-taggable-on 1.0.13 → 2.0.0.pre1

data/CHANGELOG

@@ -1,3 +1,6 @@
+== 2010-02-17
+* Converted the plugin to be compatible with Rails3
+
 == 2009-12-02
 
 * PostgreSQL is now supported (via morgoth)
@@ -12,10 +15,10 @@
 * Removed extraneous down migration cruft (azabaj)
 
 == 2008-06-09
- 
+
  * Added support for Single Table Inheritance
  * Adding gemspec and rails/init.rb for gemified plugin
- 
+
 == 2007-12-12
 
  * Added ability to use dynamic tag contexts

data/Gemfile

@@ -0,0 +1,8 @@
+source :gemcutter
+
+gem 'rails', '3.0.0.beta'
+
+group :test do
+  gem 'rspec', '2.0.0.beta.1'
+  gem 'sqlite3-ruby', :require => 'sqlite3'
+end

data/README.rdoc

@@ -89,6 +89,9 @@ also improves compatibility with the will_paginate gem:
     User.tagged_with("awesome").by_date
     User.tagged_with("awesome").by_date.paginate(:page => params[:page], :per_page => 20)
 
+    #Find a user with matching all tags, not just one
+    User.tagged_with(["awesome", "cool"], :match_all => :true)
+
 === Relationships
 
 You can find objects of the same type based on similar tags on certain contexts.
@@ -151,6 +154,12 @@ A helper is included to assist with generating tag clouds.
 
 Here is an example that generates a tag cloud.
 
+Helper:
+
+  module PostsHelper
+    include TagsHelper
+  end
+
 Controller:
 
   class PostController < ApplicationController
@@ -160,7 +169,8 @@ Controller:
   end
 
 View:
-  <% tag_cloud @tags, %w(css1 css2 css3 css4) do |tag, css_class| %>
+
+  <% tag_cloud(@tags, %w(css1 css2 css3 css4)) do |tag, css_class| %>
     <%= link_to tag.name, { :action => :tag, :id => tag.name }, :class => css_class %>
   <% end %>
 
@@ -187,5 +197,6 @@ CSS:
 * slainer68 - STI fix
 * harrylove - migration instructions and fix-ups
 * lawrencepit - cached tag work
+* sobrinho - fixed tag_cloud helper
 
 Copyright (c) 2007-2009 Michael Bleigh (http://mbleigh.com/) and Intridea Inc. (http://intridea.com/), released under the MIT license

data/Rakefile

@@ -1,4 +1,5 @@
-require 'spec/rake/spectask'
+gem 'rspec', '2.0.0.beta.1'
+require 'rspec/core/rake_task'
 
 begin
   require 'jeweler'
@@ -9,7 +10,7 @@ begin
     gemspec.email = "michael@intridea.com"
     gemspec.homepage = "http://github.com/mbleigh/acts-as-taggable-on"
     gemspec.authors = ["Michael Bleigh"]
-    gemspec.files =  FileList["[A-Z]*", "{lib,spec,rails}/**/*"] - FileList["**/*.log"]
+    gemspec.files =  FileList["[A-Z]*", "{generators,lib,spec,rails}/**/*"] - FileList["**/*.log"]
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -18,12 +19,12 @@ end
 
 desc 'Default: run specs'
 task :default => :spec
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = FileList["spec/**/*_spec.rb"]
+Rspec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
 end
 
-Spec::Rake::SpecTask.new('rcov') do |t|
-  t.spec_files = FileList["spec/**/*_spec.rb"]
+Rspec::Core::RakeTask.new('rcov') do |t|
+  t.pattern = "spec/**/*_spec.rb"
   t.rcov = true
   t.rcov_opts = ['--exclude', 'spec']
 end

data/VERSION

@@ -1 +1 @@
-1.0.13
+2.0.0.pre1

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

@@ -1,7 +1,27 @@
-require 'acts_as_taggable_on/group_helper'
-require 'acts_as_taggable_on/acts_as_taggable_on'
-require 'acts_as_taggable_on/acts_as_tagger'
-require 'acts_as_taggable_on/tag'
-require 'acts_as_taggable_on/tag_list'
-require 'acts_as_taggable_on/tags_helper'
-require 'acts_as_taggable_on/tagging'
+begin
+  # Try to require the preresolved locked set of gems.
+  require File.expand_path("../.bundle/environment", __FILE__)
+rescue LoadError
+  # Fall back on doing an unlocked resolve at runtime.
+  require "rubygems"
+  require "bundler"
+  Bundler.setup
+end
+
+Bundler.require
+
+require "active_record"
+require "action_view"
+
+require "acts_as_taggable_on/group_helper"
+require "acts_as_taggable_on/acts_as_taggable_on"
+require "acts_as_taggable_on/acts_as_tagger"
+require "acts_as_taggable_on/tag"
+require "acts_as_taggable_on/tag_list"
+require "acts_as_taggable_on/tags_helper"
+require "acts_as_taggable_on/tagging"
+
+ActiveRecord::Base.send :include, ActiveRecord::Acts::TaggableOn
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Tagger
+
+ActionView::Base.send :include, TagsHelper

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -1,11 +1,13 @@
 module ActiveRecord
   module Acts
     module TaggableOn
+
       def self.included(base)
         base.extend(ClassMethods)
       end
 
       module ClassMethods
+
         def taggable?
           false
         end
@@ -17,17 +19,19 @@ module ActiveRecord
         def acts_as_taggable_on(*args)
           args.flatten! if args
           args.compact! if args
+
           for tag_type in args
             tag_type = tag_type.to_s
-            # use aliased_join_table_name for context condition so that sphix can join multiple
+            # use aliased_join_table_name for context condition so that sphinx can join multiple
             # tag references from same model without getting an ambiguous column error
-            self.class_eval do
+            class_eval do
               has_many "#{tag_type.singularize}_taggings".to_sym, :as => :taggable, :dependent => :destroy,
-                :include => :tag, :conditions => ['#{aliased_join_table_name rescue "taggings"}.context = ?',tag_type], :class_name => "Tagging"
+                :include => :tag, :conditions => ['#{aliased_join_table_name || Tagging.table_name rescue Tagging.table_name}.context = ?',tag_type], :class_name => "Tagging"
               has_many "#{tag_type}".to_sym, :through => "#{tag_type.singularize}_taggings".to_sym, :source => :tag
             end
 
-            self.class_eval <<-RUBY
+            class_eval <<-RUBY
+
               def self.taggable?
                 true
               end
@@ -68,7 +72,7 @@ module ActiveRecord
               def find_matching_contexts(search_context, result_context, options = {})
                 matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
               end
-              
+
               def find_matching_contexts_for(klass, search_context, result_context, options = {})
                 matching_contexts_for(search_context.to_s, result_context.to_s, klass, options)
               end
@@ -80,13 +84,14 @@ module ActiveRecord
               def self.top_#{tag_type}(limit = 10)
                 tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
               end
+
             RUBY
           end
 
           if respond_to?(:tag_types)
             write_inheritable_attribute( :tag_types, (tag_types + args).uniq )
           else
-            self.class_eval do
+            class_eval do
               write_inheritable_attribute(:tag_types, args.uniq)
               class_inheritable_reader :tag_types
 
@@ -96,13 +101,12 @@ module ActiveRecord
               attr_writer :custom_contexts
 
               before_save :save_cached_tag_list
-              after_save :save_tags
 
-              if respond_to?(:named_scope)
-                named_scope :tagged_with, lambda{ |*args|
-                  find_options_for_find_tagged_with(*args)
-                }
-              end
+              after_save:save_tags
+
+              scope :tagged_with, lambda{ |*args|
+                find_options_for_find_tagged_with(*args)
+              }
             end
 
             include ActiveRecord::Acts::TaggableOn::InstanceMethods
@@ -110,68 +114,72 @@ module ActiveRecord
             alias_method_chain :reload, :tag_list
           end
         end
+
       end
 
       module SingletonMethods
+
         include ActiveRecord::Acts::TaggableOn::GroupHelper
+
         # Pass either a tag string, or an array of strings or tags
         #
         # Options:
+        #   :any - find models that match any of the given tags
         #   :exclude - Find models that are not tagged with the given tags
         #   :match_all - Find models that match all of the given tags, not just one
         #   :conditions - A piece of SQL conditions to add to the query
         #   :on - scopes the find to a context
-        def find_tagged_with(*args)
-          options = find_options_for_find_tagged_with(*args)
-          options.blank? ? [] : find(:all,options)
-        end
+        # def find_tagged_with(*args)
+        #   find_options_for_find_tagged_with(*args)
+        # end
 
         def caching_tag_list_on?(context)
           column_names.include?("cached_#{context.to_s.singularize}_list")
         end
 
         def tag_counts_on(context, options = {})
-          Tag.find(:all, find_options_for_tag_counts(options.merge({:on => context.to_s})))
+          find_for_tag_counts(options.merge({:on => context.to_s}))
         end
 
         def all_tag_counts(options = {})
-          Tag.find(:all, find_options_for_tag_counts(options))
+          find_for_tag_counts(options)
         end
 
         def find_options_for_find_tagged_with(tags, options = {})
-          tags = TagList.from(tags)
+          tag_list = TagList.from(tags)
 
-          return {} if tags.empty?
+          return {} if tag_list.empty?
 
           joins = []
           conditions = []
 
           context = options.delete(:on)
 
-
           if options.delete(:exclude)
-            tags_conditions = tags.map { |t| sanitize_sql(["#{Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
+            tags_conditions = tag_list.map { |t| sanitize_sql(["#{Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
             conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name} JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND (#{tags_conditions}) WHERE #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
 
+          elsif options.delete(:any)
+            tags_conditions = tag_list.map { |t| sanitize_sql(["#{Tag.table_name}.name LIKE ?", t]) }.join(" OR ")
+            conditions << "#{table_name}.#{primary_key} IN (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name} JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND (#{tags_conditions}) WHERE #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
+
           else
+            tags = Tag.named_any(tag_list)
+            return { :conditions => "1 = 0" } unless tags.length == tag_list.length
+
             tags.each do |tag|
-              safe_tag = tag.gsub(/[^a-zA-Z0-9]/, '')
+              safe_tag = tag.name.gsub(/[^a-zA-Z0-9]/, '')
               prefix   = "#{safe_tag}_#{rand(1024)}"
 
               taggings_alias = "#{table_name}_taggings_#{prefix}"
-              tags_alias     = "#{table_name}_tags_#{prefix}"
 
               tagging_join  = "JOIN #{Tagging.table_name} #{taggings_alias}" +
                               "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
-                              " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}"
+                              " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}" +
+                              " AND #{taggings_alias}.tag_id = #{tag.id}"
               tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
-              tag_join     = "JOIN #{Tag.table_name} #{tags_alias}" +
-                             "  ON #{tags_alias}.id = #{taggings_alias}.tag_id" +
-                             " AND " + sanitize_sql(["#{tags_alias}.name like ?", tag])
-
               joins << tagging_join
-              joins << tag_join
             end
           end
 
@@ -185,9 +193,12 @@ module ActiveRecord
             group = "#{grouped_column_names_for(self)} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
           end
 
-          { :joins      => joins.join(" "),
-            :group      => group,
-            :conditions => conditions.join(" AND ") }.update(options)
+          Tag.joins(joins.join(" ")).group(group).where(conditions.join(" AND ")).readonly(false)
+
+          # { :joins      => joins.join(" "),
+          #   :group      => group,
+          #   :conditions => conditions.join(" AND "),
+          #   :readonly   => false }.update(options)
         end
 
         # Calculate the tag counts for all tags.
@@ -201,10 +212,9 @@ module ActiveRecord
         #  :at_least - Exclude tags with a frequency less than the given value
         #  :at_most - Exclude tags with a frequency greater than the given value
         #  :on - Scope the find to only include a certain context
-        def find_options_for_tag_counts(options = {})
+        def find_for_tag_counts(options = {})
           options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
 
-          scope = scope(:find)
           start_at = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
           end_at = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
 
@@ -221,40 +231,34 @@ module ActiveRecord
           ]
 
           conditions = conditions.compact.join(' AND ')
-          conditions = merge_conditions(conditions, scope[:conditions]) if scope
 
           joins = ["LEFT OUTER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"]
           joins << sanitize_sql(["AND #{Tagging.table_name}.context = ?",options.delete(:on).to_s]) unless options[:on].nil?
-
           joins << " INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"
-          unless self.descends_from_active_record?
+
+          unless descends_from_active_record?
             # Current model is STI descendant, so add type checking to the join condition
-            joins << " AND #{table_name}.#{self.inheritance_column} = '#{self.name}'"
+            joins << " AND #{table_name}.#{inheritance_column} = '#{name}'"
           end
 
-          joins << scope[:joins] if scope && scope[:joins]
-
           at_least  = sanitize_sql(['COUNT(*) >= ?', options.delete(:at_least)]) if options[:at_least]
           at_most   = sanitize_sql(['COUNT(*) <= ?', options.delete(:at_most)]) if options[:at_most]
           having    = [at_least, at_most].compact.join(' AND ')
           group_by  = "#{grouped_column_names_for(Tag)} HAVING COUNT(*) > 0"
           group_by << " AND #{having}" unless having.blank?
 
-          { :select     => "#{Tag.table_name}.*, COUNT(*) AS count",
-            :joins      => joins.join(" "),
-            :conditions => conditions,
-            :group      => group_by,
-            :limit      => options[:limit],
-            :order      => options[:order]
-          }
+          Tag.select("#{Tag.table_name}.*, COUNT(*) AS count").joins(joins.join(" ")).where(conditions).group(group_by).limit(options[:limit]).order(options[:order])
+
         end
 
         def is_taggable?
           true
         end
+
       end
 
       module InstanceMethods
+
         include ActiveRecord::Acts::TaggableOn::GroupHelper
 
         def custom_contexts
@@ -269,51 +273,68 @@ module ActiveRecord
           custom_contexts << value.to_s unless custom_contexts.include?(value.to_s) or self.class.tag_types.map(&:to_s).include?(value.to_s)
         end
 
-        def tag_list_on(context, owner=nil)
-          var_name = context.to_s.singularize + "_list"
+        def tag_list_on(context, owner = nil)
           add_custom_context(context)
-          return instance_variable_get("@#{var_name}") unless instance_variable_get("@#{var_name}").nil?
+          cache = tag_list_cache_on(context)
+          return owner ? cache[owner] : cache[owner] if cache[owner]
 
           if !owner && self.class.caching_tag_list_on?(context) and !(cached_value = cached_tag_list_on(context)).nil?
-            instance_variable_set("@#{var_name}", TagList.from(self["cached_#{var_name}"]))
+            cache[owner] = TagList.from(cached_tag_list_on(context))
           else
-            instance_variable_set("@#{var_name}", TagList.new(*tags_on(context, owner).map(&:name)))
+            cache[owner] = TagList.new(*tags_on(context, owner).map(&:name))
           end
         end
 
-        def tags_on(context, owner=nil)
+        def all_tags_list_on(context)
+          variable_name = "@all_#{context.to_s.singularize}_list"
+          return instance_variable_get(variable_name) if instance_variable_get(variable_name)
+          instance_variable_set(variable_name, TagList.new(all_tags_on(context).map(&:name)).freeze)
+        end
+
+        def all_tags_on(context)
+          opts =  ["#{Tagging.table_name}.context = ?", context.to_s]
+          base_tags.where(opts).order("#{Tagging.table_name}.created_at")
+        end
+
+        def tags_on(context, owner = nil)
           if owner
-            opts = {:conditions => ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id = ? AND #{Tagging.table_name}.tagger_type = ?",
-                                    context.to_s, owner.id, owner.class.to_s]}
+            opts = ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id = ? AND #{Tagging.table_name}.tagger_type = ?", context.to_s, owner.id, owner.class.to_s]
           else
-            opts = {:conditions => ["#{Tagging.table_name}.context = ?", context.to_s]}
+            opts = ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id IS NULL", context.to_s]
           end
-          base_tags.find(:all, opts)
+          base_tags.where(opts)
         end
 
         def cached_tag_list_on(context)
           self["cached_#{context.to_s.singularize}_list"]
         end
 
-        def set_tag_list_on(context,new_list, tagger=nil)
-          instance_variable_set("@#{context.to_s.singularize}_list", TagList.from_owner(tagger, new_list))
+        def tag_list_cache_on(context)
+          variable_name = "@#{context.to_s.singularize}_list"
+          cache = instance_variable_get(variable_name)
+          instance_variable_set(variable_name, cache = {}) unless cache
+          cache
+        end
+
+        def set_tag_list_on(context, new_list, tagger = nil)
+          tag_list_cache_on(context)[tagger] = TagList.from(new_list)
           add_custom_context(context)
         end
 
         def tag_counts_on(context, options={})
-          self.class.tag_counts_on(context, options.merge(:id => self.id))
+          self.class.tag_counts_on(context, options.merge(:id => id))
         end
 
         def related_tags_for(context, klass, options = {})
           search_conditions = related_search_options(context, klass, options)
 
-          klass.find(:all, search_conditions)
+          klass.select(search_conditions[:select]).from(search_conditions[:from]).where(search_conditions[:conditions]).group(search_conditions[:group]).order(search_conditions[:order])
         end
 
         def related_search_options(context, klass, options = {})
-          tags_to_find = self.tags_on(context).collect { |t| t.name }
+          tags_to_find = tags_on(context).collect { |t| t.name }
 
-          exclude_self = "#{klass.table_name}.id != #{self.id} AND" if self.class == klass
+          exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
 
           { :select     => "#{klass.table_name}.*, COUNT(#{Tag.table_name}.id) AS count",
             :from       => "#{klass.table_name}, #{Tag.table_name}, #{Tagging.table_name}",
@@ -322,17 +343,17 @@ module ActiveRecord
             :order      => "count DESC"
           }.update(options)
         end
-        
+
         def matching_contexts_for(search_context, result_context, klass, options = {})
           search_conditions = matching_context_search_options(search_context, result_context, klass, options)
 
-          klass.find(:all, search_conditions)
+          klass.select(search_conditions[:select]).from(search_conditions[:from]).where(search_conditions[:conditions]).group(search_conditions[:group]).order(search_conditions[:order])
         end
-        
+
         def matching_context_search_options(search_context, result_context, klass, options = {})
-          tags_to_find = self.tags_on(search_context).collect { |t| t.name }
+          tags_to_find = tags_on(search_context).collect { |t| t.name }
 
-          exclude_self = "#{klass.table_name}.id != #{self.id} AND" if self.class == klass
+          exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
 
           { :select     => "#{klass.table_name}.*, COUNT(#{Tag.table_name}.id) AS count",
             :from       => "#{klass.table_name}, #{Tag.table_name}, #{Tagging.table_name}",
@@ -341,28 +362,49 @@ module ActiveRecord
             :order      => "count DESC"
           }.update(options)
         end
-        
+
         def save_cached_tag_list
           self.class.tag_types.map(&:to_s).each do |tag_type|
             if self.class.send("caching_#{tag_type.singularize}_list?")
-              self["cached_#{tag_type.singularize}_list"] = send("#{tag_type.singularize}_list").to_s
+              self["cached_#{tag_type.singularize}_list"] = tag_list_cache_on(tag_type.singularize).to_a.flatten.compact.join(', ')
             end
           end
         end
 
         def save_tags
-          (custom_contexts + self.class.tag_types.map(&:to_s)).each do |tag_type|
-            next unless instance_variable_get("@#{tag_type.singularize}_list")
-            owner = instance_variable_get("@#{tag_type.singularize}_list").owner
-            new_tag_names = instance_variable_get("@#{tag_type.singularize}_list") - tags_on(tag_type).map(&:name)
-            old_tags = tags_on(tag_type, owner).reject { |tag| instance_variable_get("@#{tag_type.singularize}_list").include?(tag.name) }
-
-            self.class.transaction do
-              base_tags.delete(*old_tags) if old_tags.any?
-              new_tag_names.each do |new_tag_name|
-                new_tag = Tag.find_or_create_with_like_by_name(new_tag_name)
-                Tagging.create(:tag_id => new_tag.id, :context => tag_type,
-                               :taggable => self, :tagger => owner)
+          contexts = custom_contexts + self.class.tag_types.map(&:to_s)
+
+          transaction do
+            contexts.each do |context|
+              cache = tag_list_cache_on(context)
+
+              cache.each do |owner, list|
+                new_tags = Tag.find_or_create_all_with_like_by_name(list.uniq)
+                taggings = Tagging.where({ :taggable_id => self.id, :taggable_type => self.class.base_class.to_s })
+
+                # Destroy old taggings:
+                if owner
+                  old_tags = tags_on(context, owner) - new_tags
+                  old_taggings = Tagging.where({ :taggable_id => self.id, :taggable_type => self.class.base_class.to_s, :tag_id => old_tags, :tagger_id => owner.id, :tagger_type => owner.class.to_s, :context => context })
+
+                  Tagging.destroy_all :id => old_taggings.map(&:id)
+                else
+                  old_tags = tags_on(context) - new_tags
+                  base_tags.delete(*old_tags)
+                end
+
+                new_tags.reject! { |tag| taggings.any? { |tagging|
+                    tagging.tag_id      == tag.id &&
+                    tagging.tagger_id   == (owner ? owner.id : nil) &&
+                    tagging.tagger_type == (owner ? owner.class.to_s : nil) &&
+                    tagging.context     == context
+                  }
+                }
+
+                # create new taggings:
+                new_tags.each do |tag|
+                  Tagging.create!(:tag_id => tag.id, :context => context, :tagger => owner, :taggable => self)
+                end
               end
             end
           end
@@ -372,11 +414,12 @@ module ActiveRecord
 
         def reload_with_tag_list(*args)
           self.class.tag_types.each do |tag_type|
-            self.instance_variable_set("@#{tag_type.to_s.singularize}_list", nil)
+            instance_variable_set("@#{tag_type.to_s.singularize}_list", nil)
           end
 
           reload_without_tag_list(*args)
         end
+
       end
     end
   end

data/lib/acts_as_taggable_on/acts_as_tagger.rb

@@ -1,52 +1,60 @@
 module ActiveRecord
   module Acts
     module Tagger
+
       def self.included(base)
         base.extend ClassMethods
       end
-      
+
       module ClassMethods
+
         def acts_as_tagger(opts={})
-          has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy, 
+          has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy,
                                                :include => :tag, :class_name => "Tagging")
           has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true
+
           include ActiveRecord::Acts::Tagger::InstanceMethods
-          extend ActiveRecord::Acts::Tagger::SingletonMethods       
+          extend ActiveRecord::Acts::Tagger::SingletonMethods
         end
-        
+
         def is_tagger?
           false
         end
+
       end
-      
+
       module InstanceMethods
+
         def self.included(base)
         end
-        
+
         def tag(taggable, opts={})
           opts.reverse_merge!(:force => true)
 
           return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
-          raise "You need to specify a tag context using :on" unless opts.has_key?(:on)
-          raise "You need to specify some tags using :with" unless opts.has_key?(:with)
-          raise "No context :#{opts[:on]} defined in #{taggable.class.to_s}" unless 
-              ( opts[:force] || taggable.tag_types.include?(opts[:on]) )
+
+          raise "You need to specify a tag context using :on"                unless opts.has_key?(:on)
+          raise "You need to specify some tags using :with"                  unless opts.has_key?(:with)
+          raise "No context :#{opts[:on]} defined in #{taggable.class.to_s}" unless (opts[:force] || taggable.tag_types.include?(opts[:on]))
 
           taggable.set_tag_list_on(opts[:on].to_s, opts[:with], self)
           taggable.save
         end
-        
+
         def is_tagger?
           self.class.is_tagger?
         end
+
       end
-      
+
       module SingletonMethods
+
         def is_tagger?
           true
         end
+
       end
-      
+
     end
   end
 end

data/lib/acts_as_taggable_on/group_helper.rb

@@ -2,10 +2,12 @@ module ActiveRecord
   module Acts
     module TaggableOn
       module GroupHelper
+
         # 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(", ")
         end
+
       end
     end
   end