acts-as-taggable-on 1.0.12 → 1.1.1

data/README.rdoc

@@ -137,6 +137,46 @@ Tags can have owners:
     @some_user.owned_taggings
     @some_user.owned_tags
     @some_photo.locations_from(@some_user)
+    
+=== Tag cloud calculations
+
+To construct tag clouds, the frequency of each tag needs to be calculated.
+Because we specified +acts_as_taggable_on+ on the <tt>User</tt> class, we can
+get a calculation of all the tag counts by using <tt>User.tag_counts_on(:customs)</tt>. But what if we wanted a tag count for
+an single user's posts? To achieve this we call tag_counts on the association:
+
+  User.find(:first).posts.tag_counts_on(:tags)
+
+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
+    def tag_cloud
+      @tags = Post.tag_counts_on(:tags)
+    end
+  end
+
+View:
+
+  <% 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 %>
+
+CSS:
+
+  .css1 { font-size: 1.0em; }
+  .css2 { font-size: 1.2em; }
+  .css3 { font-size: 1.4em; }
+  .css4 { font-size: 1.6em; }
 
 == Contributors
 
@@ -154,5 +194,6 @@ Tags can have owners:
 * 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

@@ -9,7 +9,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
@@ -21,3 +21,9 @@ task :default => :spec
 Spec::Rake::SpecTask.new do |t|
   t.spec_files = FileList["spec/**/*_spec.rb"]
 end
+
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end

data/VERSION

@@ -1 +1 @@
-1.0.12
+1.1.1

data/generators/acts_as_taggable_on_migration/acts_as_taggable_on_migration_generator.rb

@@ -0,0 +1,7 @@
+class ActsAsTaggableOnMigrationGenerator < Rails::Generator::Base 
+  def manifest 
+    record do |m| 
+      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => "acts_as_taggable_on_migration"
+    end
+  end
+end

data/generators/acts_as_taggable_on_migration/templates/migration.rb

@@ -0,0 +1,29 @@
+class ActsAsTaggableOnMigration < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.column :name, :string
+    end
+    
+    create_table :taggings do |t|
+      t.column :tag_id, :integer
+      t.column :taggable_id, :integer
+      t.column :tagger_id, :integer
+      t.column :tagger_type, :string
+      
+      # You should make sure that the column created is
+      # long enough to store the required class names.
+      t.column :taggable_type, :string
+      t.column :context, :string
+      
+      t.column :created_at, :datetime
+    end
+    
+    add_index :taggings, :tag_id
+    add_index :taggings, [:taggable_id, :taggable_type, :context]
+  end
+  
+  def self.down
+    drop_table :taggings
+    drop_table :tags
+  end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -19,15 +19,15 @@ module ActiveRecord
           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
@@ -65,6 +65,14 @@ module ActiveRecord
                 related_tags_for('#{tag_type}', klass, options)
               end
 
+              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
+
               def top_#{tag_type}(limit = 10)
                 tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
               end
@@ -74,11 +82,10 @@ module ActiveRecord
               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
 
@@ -102,10 +109,6 @@ module ActiveRecord
             alias_method_chain :reload, :tag_list
           end
         end
-
-        def is_taggable?
-          false
-        end
       end
 
       module SingletonMethods
@@ -113,6 +116,7 @@ module ActiveRecord
         # 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
@@ -135,9 +139,9 @@ module ActiveRecord
         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 = []
@@ -146,28 +150,30 @@ module ActiveRecord
 
 
           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_like_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
 
@@ -183,7 +189,8 @@ module ActiveRecord
 
           { :joins      => joins.join(" "),
             :group      => group,
-            :conditions => conditions.join(" AND ") }.update(options)
+            :conditions => conditions.join(" AND "),
+            :readonly   => false }.update(options)
         end
 
         # Calculate the tag counts for all tags.
@@ -221,14 +228,32 @@ module ActiveRecord
 
           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]
+          # Based on a proposed patch by donV to ActiveRecord Base
+          # This is needed because merge_joins and construct_join are private in ActiveRecord Base
+          if scope && scope[:joins]
+            case scope[:joins]
+            when Array
+              scope_joins = scope[:joins].flatten
+              strings = scope_joins.select{|j| j.is_a? String}
+              joins << strings.join(' ') + " "
+              symbols = scope_joins - strings
+              join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, symbols, nil)
+              joins << " #{join_dependency.join_associations.collect { |assoc| assoc.association_join }.join} "
+              joins.flatten!
+            when Symbol, Hash
+              join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, scope[:joins], nil)
+              joins << " #{join_dependency.join_associations.collect { |assoc| assoc.association_join }.join} "
+            when String
+              joins << scope[:joins]
+            end
+          end
 
           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]
@@ -253,10 +278,6 @@ module ActiveRecord
       module InstanceMethods
         include ActiveRecord::Acts::TaggableOn::GroupHelper
 
-        def tag_types
-          self.class.tag_types
-        end
-
         def custom_contexts
           @custom_contexts ||= []
         end
@@ -264,29 +285,40 @@ module ActiveRecord
         def is_taggable?
           self.class.is_taggable?
         end
-
+        
         def add_custom_context(value)
           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 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 = {:conditions => ["#{Tagging.table_name}.context = ?", context.to_s]}
+          base_tags.find(:all, opts.merge(:order => "#{Tagging.table_name}.created_at"))
+        end
 
-        def tags_on(context, owner=nil)
+        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]}
           else
-            opts = {:conditions => ["#{Tagging.table_name}.context = ?", context.to_s]}
+            opts = {:conditions => ["#{Tagging.table_name}.context = ? AND #{Tagging.table_name}.tagger_id IS NULL", context.to_s]}
           end
           base_tags.find(:all, opts)
         end
@@ -294,14 +326,21 @@ module ActiveRecord
         def cached_tag_list_on(context)
           self["cached_#{context.to_s.singularize}_list"]
         end
+        
+        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)
-          instance_variable_set("@#{context.to_s.singularize}_list", TagList.from_owner(tagger, new_list))
+        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 = {})
@@ -311,9 +350,9 @@ module ActiveRecord
         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,38 +361,72 @@ 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)
+        end
+        
+        def matching_context_search_options(search_context, result_context, klass, options = {})
+          tags_to_find = tags_on(search_context).collect { |t| t.name }
+
+          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}",
+            :conditions => ["#{exclude_self} #{klass.table_name}.id = #{Tagging.table_name}.taggable_id AND #{Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{Tagging.table_name}.tag_id = #{Tag.table_name}.id AND #{Tag.table_name}.name IN (?) AND #{Tagging.table_name}.context = ?", tags_to_find, result_context],
+            :group      => grouped_column_names_for(klass),
+            :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).tags.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)
+
+                # Destroy old taggings:
+                if owner
+                  old_tags = tags_on(context, owner) - new_tags
+                  old_taggings = taggings.find(:all, :conditions => { :tag_id => old_tags, :tagger_id => owner, :tagger_type => owner.class.to_s, :context => context })
+                  old_taggings.each(&:destroy)
+                else                  
+                  old_tags = tags_on(context) - new_tags
+                  base_tags.delete(*old_tags)                
+                end
+                
+                new_tags.reject! { |tag| taggings.any? { |tagging| tagging.tag     == tag   &&
+                                                                   tagging.tagger  == owner &&
+                                                                   tagging.context == context } }
+                
+                # create new taggings:
+                new_tags.each do |tag|
+                  taggings.create!(:tag_id => tag.id, :context => context, :tagger => owner)
+                end
               end
             end
-          end
+          end          
 
           true
         end
 
         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)

data/lib/acts_as_taggable_on/tag.rb

@@ -1,14 +1,41 @@
 class Tag < ActiveRecord::Base
-  has_many :taggings
+  
+  attr_accessible :name
+  
+  ### ASSOCIATIONS:
+  
+  has_many :taggings, :dependent => :destroy
+  
+  ### VALIDATIONS:
   
   validates_presence_of :name
   validates_uniqueness_of :name
   
-  # LIKE is used for cross-database case-insensitivity
+  ### NAMED SCOPES:
+  
+  named_scope :named, lambda { |name| { :conditions => ["name LIKE ?", name] } }
+  named_scope :named_any, lambda { |list| { :conditions => list.map { |tag| sanitize_sql(["name LIKE ?", tag.to_s]) }.join(" OR ") } }
+  named_scope :named_like, lambda { |name| { :conditions => ["name LIKE ?", "%#{name}%"] } }
+  named_scope :named_like_any, lambda { |list| { :conditions => list.map { |tag| sanitize_sql(["name LIKE ?", "%#{tag.to_s}%"]) }.join(" OR ") } }
+  
+  ### CLASS METHODS:
+  
   def self.find_or_create_with_like_by_name(name)
-    find(:first, :conditions => ["name LIKE ?", name]) || create(:name => name)
+    named_like(name).first || create(:name => name)
   end
   
+  def self.find_or_create_all_with_like_by_name(*list)
+    list = [list].flatten
+
+    existing_tags = Tag.named_any(list).all
+    new_tag_names = list.reject { |name| existing_tags.any? { |tag| tag.name.downcase == name.downcase } }
+    created_tags  = new_tag_names.map { |name| Tag.create(:name => name) }
+  
+    existing_tags + created_tags    
+  end
+  
+  ### INSTANCE METHODS:
+  
   def ==(object)
     super || (object.is_a?(Tag) && name == object.name)
   end

data/lib/acts_as_taggable_on/tag_list.rb

@@ -41,9 +41,10 @@ class TagList < Array
   #   tag_list = TagList.new("Round", "Square,Cube")
   #   tag_list.to_s # 'Round, "Square,Cube"'
   def to_s
-    clean!
+    tags = frozen? ? self.dup : self
+    tags.send(:clean!)
     
-    map do |name|
+    tags.map do |name|
       name.include?(delimiter) ? "\"#{name}\"" : name
     end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
   end
@@ -55,7 +56,7 @@ class TagList < Array
     map!(&:strip)
     uniq!
   end
-  
+    
   def extract_and_apply_options!(args)
     options = args.last.is_a?(Hash) ? args.pop : {}
     options.assert_valid_keys :parse
@@ -79,17 +80,11 @@ class TagList < Array
         string = string.to_s.dup
         
         # Parse the quoted tags
-        string.gsub!(/"(.*?)"\s*#{delimiter}?\s*/) { tag_list << $1; "" }
-        string.gsub!(/'(.*?)'\s*#{delimiter}?\s*/) { tag_list << $1; "" }
+        string.gsub!(/(\A|#{delimiter})\s*"(.*?)"\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
+        string.gsub!(/(\A|#{delimiter})\s*'(.*?)'\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
         
         tag_list.add(string.split(delimiter))
       end
     end
-    
-    def from_owner(owner, *tags)
-      returning from(*tags) do |taglist|
-        taglist.owner = owner
-      end
-    end
   end
 end

data/lib/acts_as_taggable_on/tagging.rb

@@ -1,6 +1,14 @@
 class Tagging < ActiveRecord::Base #:nodoc:
+  attr_accessible :tag, :tag_id, :context,
+                  :taggable, :taggable_type, :taggable_id,
+                  :tagger, :tagger_type, :tagger_id
+
   belongs_to :tag
   belongs_to :taggable, :polymorphic => true
   belongs_to :tagger, :polymorphic => true
+  
   validates_presence_of :context
+  validates_presence_of :tag_id
+  
+  validates_uniqueness_of :tag_id, :scope => [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
 end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -1,6 +1,8 @@
 module TagsHelper
   # See the README for an example using tag_cloud.
   def tag_cloud(tags, classes)
+    return [] if tags.empty?
+
     max_count = tags.sort_by(&:count).last.count.to_f
     
     tags.each do |tag|

data/rails/init.rb

@@ -2,5 +2,4 @@ require 'acts-as-taggable-on'
 
 ActiveRecord::Base.send :include, ActiveRecord::Acts::TaggableOn
 ActiveRecord::Base.send :include, ActiveRecord::Acts::Tagger
-
-RAILS_DEFAULT_LOGGER.info "** acts_as_taggable_on: initialized properly."
+ActionView::Base.send :include, TagsHelper if defined?(ActionView::Base)

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -18,6 +18,10 @@ describe "Acts As Taggable On" do
     it "should create a class attribute for tag types" do
       @taggable.class.should respond_to(:tag_types)
     end
+    
+    it "should create an instance attribute for tag types" do
+      @taggable.should respond_to(:tag_types)
+    end
 
     it "should generate an association for each tag type" do
       @taggable.should respond_to(:tags, :skills, :languages)
@@ -119,17 +123,59 @@ describe "Acts As Taggable On" do
     end
   end
 
-  describe 'Tagging Contexts' do
-    before(:all) do
-      class Array
-        def freq
-          k=Hash.new(0)
-          self.each {|e| k[e]+=1}
-          k
-        end
-      end
+  describe "Matching Contexts" do
+    it "should find objects with tags of matching contexts" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = TaggableModel.create!(:name => "Taggable 2")
+      taggable3 = TaggableModel.create!(:name => "Taggable 3")
+
+      taggable1.offering_list = "one, two"
+      taggable1.save!
+
+      taggable2.need_list = "one, two"
+      taggable2.save!
+
+      taggable3.offering_list = "one, two"
+      taggable3.save!
+
+      taggable1.find_matching_contexts(:offerings, :needs).should include(taggable2)
+      taggable1.find_matching_contexts(:offerings, :needs).should_not include(taggable3)
     end
 
+    it "should find other related objects with tags of matching contexts" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = OtherTaggableModel.create!(:name => "Taggable 2")
+      taggable3 = OtherTaggableModel.create!(:name => "Taggable 3")
+
+      taggable1.offering_list = "one, two"
+      taggable1.save
+
+      taggable2.need_list = "one, two"
+      taggable2.save
+
+      taggable3.offering_list = "one, two"
+      taggable3.save
+
+      taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should include(taggable2)
+      taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should_not include(taggable3)
+    end
+
+    it "should not include the object itself in the list of related objects" do
+      taggable1 = TaggableModel.create!(:name => "Taggable 1")
+      taggable2 = TaggableModel.create!(:name => "Taggable 2")
+
+      taggable1.tag_list = "one"
+      taggable1.save
+
+      taggable2.tag_list = "one, two"
+      taggable2.save
+
+      taggable1.find_related_tags.should include(taggable2)
+      taggable1.find_related_tags.should_not include(taggable1)
+    end
+  end
+
+  describe 'Tagging Contexts' do
     it 'should eliminate duplicate tagging contexts ' do
       TaggableModel.acts_as_taggable_on(:skills, :skills)
       TaggableModel.tag_types.freq[:skills].should_not == 3
@@ -156,10 +202,6 @@ describe "Acts As Taggable On" do
         TaggableModel.acts_as_taggable_on([nil])
       }.should_not raise_error
     end
-
-    after(:all) do
-      class Array; remove_method :freq; end
-    end
   end
 
 end

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -1,8 +1,11 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe "acts_as_tagger" do
+  before(:each) do
+    [TaggableUser, TaggableModel, Tagging, Tag].each(&:destroy_all)
+  end
+  
   context "Tagger Method Generation" do
-
     before(:each) do
       @tagger = TaggableUser.new()
     end
@@ -48,8 +51,22 @@ describe "acts_as_tagger" do
       
       it 'should by default create the tag context on-the-fly' do
         @taggable.tag_list_on(:here_ond_now).should be_empty
-        @tagger.tag(@taggable, :with=>'that', :on=>:here_ond_now)
-        @taggable.tag_list_on(:here_ond_now).should include('that')
+        @tagger.tag(@taggable, :with=>'that', :on => :here_ond_now)
+        @taggable.tag_list_on(:here_ond_now).should_not include('that')
+        @taggable.all_tags_list_on(:here_ond_now).should include('that')
+      end
+      
+      it "should show all the tag list when both public and owned tags exist" do
+        @taggable.tag_list = 'ruby, python'
+        @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
+        @taggable.all_tags_on(:tags).map(&:name).sort.should == %w(ruby python java lisp).sort
+      end
+      
+      it "should not add owned tags to the common list" do
+        @taggable.tag_list = 'ruby, python'
+        @tagger.tag(@taggable, :with => 'java, lisp', :on => :foo)
+        @tagger.tag(@taggable, :with => '', :on => :foo)
+        @taggable.tag_list.should == %w(ruby python)
       end
       
       it "should throw an exception when the default is over-ridden" do
@@ -64,9 +81,28 @@ describe "acts_as_tagger" do
         @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo_boo, :force=>false) rescue
         @taggable.tag_list_on(:foo_boo).should be_empty
       end
-
     end
-  
+    
+    context "when called by multiple tagger's" do
+      before(:each) do
+        @user_x = TaggableUser.new
+        @user_y = TaggableUser.new
+        @taggable = TaggableModel.new(:name => 'acts_as_taggable_on', :tag_list => 'plugin')
+        
+        @user_x.tag(@taggable, :with => 'ruby, rails',  :on => :tags)
+        @user_y.tag(@taggable, :with => 'ruby, plugin', :on => :tags)
+      end
+      
+      it "should not delete other taggers tags" do
+        @user_y.tag(@taggable, :with => '', :on => :tags)
+        @taggable.all_tags_list_on(:tags).should include('ruby')
+      end
+      
+      it "should not delete original tags" do
+        @user_y.tag(@taggable, :with => '', :on => :tags)
+        @taggable.all_tags_list_on(:tags).should include('plugin')
+      end
+    end
   end
 
 end

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -20,6 +20,18 @@ describe TagList do
     @tag_list.include?("wicked").should be_true
   end
   
+  it "should be able to add delimited list of words with quoted delimiters" do
+    @tag_list.add("'cool, wicked', \"really cool, really wicked\"", :parse => true)
+    @tag_list.include?("cool, wicked").should be_true
+    @tag_list.include?("really cool, really wicked").should be_true
+  end
+  
+  it "should be able to handle other uses of quotation marks correctly" do
+    @tag_list.add("john's cool car, mary's wicked toy", :parse => true)
+    @tag_list.include?("john's cool car").should be_true
+    @tag_list.include?("mary's wicked toy").should be_true
+  end
+  
   it "should be able to add an array of words" do
     @tag_list.add(["cool", "wicked"], :parse => true)
     @tag_list.include?("cool").should be_true
@@ -49,4 +61,10 @@ describe TagList do
     @tag_list.add("cool","rad,bodacious")
     @tag_list.to_s.should == "awesome, radical, cool, \"rad,bodacious\""
   end
+  
+  it "should be able to call to_s on a frozen tag list" do
+    @tag_list.freeze
+    lambda { @tag_list.add("cool","rad,bodacious") }.should raise_error
+    lambda { @tag_list.to_s }.should_not raise_error
+  end
 end

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -4,8 +4,68 @@ describe Tag do
   before(:each) do
     @tag = Tag.new
     @user = TaggableModel.create(:name => "Pablo")  
+    Tag.delete_all
   end
   
+  describe "named like any" do
+    before(:each) do
+      Tag.create(:name => "awesome")
+      Tag.create(:name => "epic")
+    end
+    
+    it "should find both tags" do
+      Tag.named_like_any(["awesome", "epic"]).should have(2).items
+    end
+  end
+  
+  describe "find or create by name" do
+    before(:each) do
+      @tag.name = "awesome"
+      @tag.save
+    end
+    
+    it "should find by name" do
+      Tag.find_or_create_with_like_by_name("awesome").should == @tag
+    end
+    
+    it "should find by name case insensitive" do
+      Tag.find_or_create_with_like_by_name("AWESOME").should == @tag
+    end
+    
+    it "should create by name" do
+      lambda {
+        Tag.find_or_create_with_like_by_name("epic")
+      }.should change(Tag, :count).by(1)
+    end
+  end
+  
+  describe "find or create all by any name" do
+    before(:each) do
+      @tag.name = "awesome"
+      @tag.save
+    end
+    
+    it "should find by name" do
+      Tag.find_or_create_all_with_like_by_name("awesome").should == [@tag]
+    end
+    
+    it "should find by name case insensitive" do
+      Tag.find_or_create_all_with_like_by_name("AWESOME").should == [@tag]
+    end
+    
+    it "should create by name" do
+      lambda {
+        Tag.find_or_create_all_with_like_by_name("epic")
+      }.should change(Tag, :count).by(1)
+    end
+    
+    it "should find or create by name" do
+      lambda {
+        Tag.find_or_create_all_with_like_by_name("awesome", "epic").map(&:name).should == ["awesome", "epic"]
+      }.should change(Tag, :count).by(1)      
+    end
+  end
+
   it "should require a name" do
     @tag.valid?
     @tag.errors.on(:name).should == "can't be blank"
@@ -24,4 +84,17 @@ describe Tag do
     @tag.name = "cool"
     @tag.to_s.should == "cool"
   end
+  
+  it "have named_scope named(something)" do
+    @tag.name = "cool"
+    @tag.save!
+    Tag.named('cool').should include(@tag)
+  end
+  
+  it "have named_scope named_like(something)" do
+    @tag.name = "cool"
+    @tag.save!
+    @another_tag = Tag.create!(:name => "coolip")
+    Tag.named_like('cool').should include(@tag, @another_tag)
+  end
 end

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -5,31 +5,51 @@ describe "Taggable" do
     [TaggableModel, Tag, Tagging, TaggableUser].each(&:delete_all)
     @taggable = TaggableModel.new(:name => "Bob Jones")
   end
-  
+
+  it "should have tag types" do
+      for type in [:tags, :languages, :skills, :needs, :offerings]
+        TaggableModel.tag_types.should include type
+      end
+      @taggable.tag_types.should == TaggableModel.tag_types
+  end
+
+  it "should have tag_counts_on" do
+    TaggableModel.tag_counts_on(:tags).should be_empty
+
+    @taggable.tag_list = ["awesome", "epic"]
+    @taggable.save
+
+    TaggableModel.tag_counts_on(:tags).count.should == 2
+    @taggable.tag_counts_on(:tags).count.should == 2
+  end
+
   it "should be able to create tags" do
     @taggable.skill_list = "ruby, rails, css"
-    @taggable.instance_variable_get("@skill_list").instance_of?(TagList).should be_true
+    @taggable.instance_variable_get("@skill_list").instance_of?(Hash).should be_true
+    @taggable.instance_variable_get("@skill_list")[nil].instance_of?(TagList).should be_true
     @taggable.save
-    
+
     Tag.find(:all).size.should == 3
   end
-  
+
   it "should be able to create tags through the tag list directly" do
     @taggable.tag_list_on(:test).add("hello")
-    @taggable.save    
+    @taggable.tag_list_cache_on(:test).should_not be_empty
+    @taggable.save
+    @taggable.save_tags
     @taggable.reload
     @taggable.tag_list_on(:test).should == ["hello"]
   end
-  
+
   it "should differentiate between contexts" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.tag_list = "ruby, bob, charlie"
     @taggable.save
     @taggable.reload
-    @taggable.skill_list.include?("ruby").should be_true
-    @taggable.skill_list.include?("bob").should be_false
+    @taggable.skill_list.should include("ruby")
+    @taggable.skill_list.should_not include("bob")
   end
-  
+
   it "should be able to remove tags through list alone" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.save
@@ -40,13 +60,13 @@ describe "Taggable" do
     @taggable.reload
     @taggable.should have(2).skills
   end
-  
+
   it "should be able to find by tag" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.save
     TaggableModel.find_tagged_with("ruby").first.should == @taggable
   end
-  
+
   it "should be able to find by tag with context" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.tag_list = "bob, charlie"
@@ -55,25 +75,27 @@ describe "Taggable" do
     TaggableModel.find_tagged_with("bob", :on => :skills).first.should_not == @taggable
     TaggableModel.find_tagged_with("bob", :on => :tags).first.should == @taggable
   end
-  
+
   it "should be able to use the tagged_with named scope" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.tag_list = "bob, charlie"
     @taggable.save
-    
+
     TaggableModel.tagged_with("ruby").first.should == @taggable
+    TaggableModel.tagged_with("ruby, css").first.should == @taggable
+    TaggableModel.tagged_with("ruby, nonexistingtag").should be_empty
     TaggableModel.tagged_with("bob", :on => :skills).first.should_not == @taggable
     TaggableModel.tagged_with("bob", :on => :tags).first.should == @taggable
   end
-  
+
   it "should not care about case" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "Ruby")
-    
+
     Tag.find(:all).size.should == 1
     TaggableModel.find_tagged_with("ruby").should == TaggableModel.find_tagged_with("Ruby")
   end
-  
+
   it "should be able to get tag counts on model as a whole" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
@@ -81,33 +103,39 @@ describe "Taggable" do
     TaggableModel.tag_counts.should_not be_empty
     TaggableModel.skill_counts.should_not be_empty
   end
-  
+
   it "should be able to get all tag counts on model as whole" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
     charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
-    
+
     TaggableModel.all_tag_counts.should_not be_empty
     TaggableModel.all_tag_counts.first.count.should == 3 # ruby
   end
-  
+
+  it "should not return read-only records" do
+    TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
+
+    TaggableModel.tagged_with("ruby").first.should_not be_readonly
+  end
+
   it "should be able to get scoped tag counts" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
     charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
-    
+
     TaggableModel.tagged_with("ruby").tag_counts.first.count.should == 2   # ruby
     TaggableModel.tagged_with("ruby").skill_counts.first.count.should == 1 # ruby
   end
-  
+
   it "should be able to get all scoped tag counts" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
     charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
-    
+
     TaggableModel.tagged_with("ruby").all_tag_counts.first.count.should == 3 # ruby
   end
-  
+
   it "should be able to set a custom tag context list" do
     bob = TaggableModel.create(:name => "Bob")
     bob.set_tag_list_on(:rotors, "spinning, jumping")
@@ -116,17 +144,27 @@ describe "Taggable" do
     bob.reload
     bob.tags_on(:rotors).should_not be_empty
   end
-  
+
   it "should be able to find tagged" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
     steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
-    
+
     TaggableModel.find_tagged_with("ruby", :order => 'taggable_models.name').should == [bob, frank, steve]
     TaggableModel.find_tagged_with("ruby, rails", :order => 'taggable_models.name').should == [bob, frank]
     TaggableModel.find_tagged_with(["ruby", "rails"], :order => 'taggable_models.name').should == [bob, frank]    
   end
-  
+
+  it "should be able to find tagged with any tag" do
+    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
+    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
+    steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
+
+    TaggableModel.find_tagged_with(["ruby", "java"], :order => 'taggable_models.name', :any => true).should == [bob, frank, steve]
+    TaggableModel.find_tagged_with(["c++", "fitter"], :order => 'taggable_models.name', :any => true).should == [bob, steve]
+    TaggableModel.find_tagged_with(["depressed", "css"], :order => 'taggable_models.name', :any => true).should == [bob, frank]    
+  end
+
   it "should be able to find tagged on a custom tag context" do
     bob = TaggableModel.create(:name => "Bob")
     bob.set_tag_list_on(:rotors, "spinning, jumping")
@@ -139,29 +177,38 @@ describe "Taggable" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
     steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, python')
-    
+
     # Let's only find those productive Rails developers
     TaggableModel.tagged_with('rails', :on => :skills, :order => 'taggable_models.name').should == [bob, frank]
     TaggableModel.tagged_with('happier', :on => :tags, :order => 'taggable_models.name').should == [bob, steve]
     TaggableModel.tagged_with('rails', :on => :skills).tagged_with('happier', :on => :tags).should == [bob]
     TaggableModel.tagged_with('rails').tagged_with('happier', :on => :tags).should == [bob]
   end
-  
+
   it "should be able to find tagged with only the matching tags" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "lazy, happier")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "fitter, happier, inefficient")
     steve = TaggableModel.create(:name => 'Steve', :tag_list => "fitter, happier")
-    
+
     TaggableModel.find_tagged_with("fitter, happier", :match_all => true).should == [steve]    
   end
-  
+
   it "should be able to find tagged with some excluded tags" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "happier, lazy")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "happier")
     steve = TaggableModel.create(:name => 'Steve', :tag_list => "happier")
-    
+
     TaggableModel.find_tagged_with("lazy", :exclude => true).should == [frank, steve]    
   end
+
+  it "should not create duplicate taggings" do
+    bob = TaggableModel.create(:name => "Bob")
+    lambda {
+      bob.tag_list << "happier"
+      bob.tag_list << "happier"
+      bob.save
+    }.should change(Tagging, :count).by(1)
+  end
   
   describe "Single Table Inheritance" do
     before do
@@ -170,32 +217,32 @@ describe "Taggable" do
       @inherited_same = InheritingTaggableModel.new(:name => "inherited same")
       @inherited_different = AlteredInheritingTaggableModel.new(:name => "inherited different")
     end
-    
+
     it "should be able to save tags for inherited models" do
       @inherited_same.tag_list = "bob, kelso"
       @inherited_same.save
       InheritingTaggableModel.find_tagged_with("bob").first.should == @inherited_same
     end
-    
+
     it "should find STI tagged models on the superclass" do
       @inherited_same.tag_list = "bob, kelso"
       @inherited_same.save
       TaggableModel.find_tagged_with("bob").first.should == @inherited_same
     end
-    
+
     it "should be able to add on contexts only to some subclasses" do
       @inherited_different.part_list = "fork, spoon"
       @inherited_different.save
       InheritingTaggableModel.find_tagged_with("fork", :on => :parts).should be_empty
       AlteredInheritingTaggableModel.find_tagged_with("fork", :on => :parts).first.should == @inherited_different
     end
-    
+
     it "should have different tag_counts_on for inherited models" do
       @inherited_same.tag_list = "bob, kelso"
       @inherited_same.save!
       @inherited_different.tag_list = "fork, spoon"
       @inherited_different.save!
-      
+
       InheritingTaggableModel.tag_counts_on(:tags).map(&:name).should == %w(bob kelso)
       AlteredInheritingTaggableModel.tag_counts_on(:tags).map(&:name).should == %w(fork spoon)
       TaggableModel.tag_counts_on(:tags).map(&:name).should == %w(bob kelso fork spoon)

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -6,17 +6,32 @@ describe "Tagger" do
     @user = TaggableUser.new
     @taggable = TaggableModel.new(:name => "Bob Jones")
   end
-  
+
   it "should have taggings" do
     @user.tag(@taggable, :with=>'ruby,scheme', :on=>:tags)
     @user.owned_taggings.size == 2
   end
-  
+
   it "should have tags" do
     @user.tag(@taggable, :with=>'ruby,scheme', :on=>:tags)
     @user.owned_tags.size == 2
   end
   
+  it "should not overlap or lose tags from different users" do
+    @user2 = TaggableUser.new
+    lambda{
+      @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
+      @user2.tag(@taggable, :with => 'java, python, lisp, ruby', :on => :tags)
+    }.should change(Tagging, :count).by(6)
+
+    @user.owned_tags.map(&:name).sort.should == %w(ruby scheme)
+    @user2.owned_tags.map(&:name).sort.should == %w(java python lisp ruby).sort
+    @taggable.tags_from(@user).sort.should == %w(ruby scheme)
+    @taggable.tags_from(@user2).sort.should == %w(java lisp python ruby)
+    @taggable.all_tags_list_on(:tags).sort.should == %w(ruby scheme java python lisp).sort
+    @taggable.all_tags_on(:tags).size.should == 6
+  end
+
   it "is tagger" do
     @user.is_tagger?.should(be_true)
   end  

data/spec/acts_as_taggable_on/tagging_spec.rb

@@ -4,4 +4,22 @@ describe Tagging do
   before(:each) do
     @tagging = Tagging.new
   end
+  
+  it "should not be valid with a invalid tag" do
+    @tagging.taggable = TaggableModel.create(:name => "Bob Jones")
+    @tagging.tag = Tag.new(:name => "")
+    @tagging.context = "tags"
+
+    @tagging.should_not be_valid
+    @tagging.errors.on(:tag_id).should == "can't be blank"
+  end
+  
+  it "should not create duplicate taggings" do
+    @taggable = TaggableModel.create(:name => "Bob Jones")
+    @tag = Tag.create(:name => "awesome")
+    
+    lambda {
+      2.times { Tagging.create(:taggable => @taggable, :tag => @tag, :context => 'tags') }
+    }.should change(Tagging, :count).by(1)
+  end
 end

data/spec/acts_as_taggable_on/tags_helper_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe TagsHelper do
+  before(:each) do
+    [TaggableModel, Tag, Tagging].each(&:delete_all)
+    
+    @bob = TaggableModel.create(:name => "Bob Jones",  :language_list => "ruby, php")
+    @tom = TaggableModel.create(:name => "Tom Marley", :language_list => "ruby, java")
+    @eve = TaggableModel.create(:name => "Eve Nodd",   :language_list => "ruby, c++")
+    
+    @helper = class Helper
+      include TagsHelper
+    end.new
+    
+    
+  end
+  
+  it "should yield the proper css classes" do 
+    tags = { }
+    
+    @helper.tag_cloud(TaggableModel.tag_counts_on(:languages), ["sucky", "awesome"]) do |tag, css_class|
+      tags[tag.name] = css_class
+    end
+    
+    tags["ruby"].should == "awesome"
+    tags["java"].should == "sucky"
+    tags["c++"].should == "sucky"
+    tags["php"].should == "sucky"
+  end
+end

data/spec/spec_helper.rb

@@ -1,12 +1,20 @@
 # require File.dirname(__FILE__) + '/../../../../spec/spec_helper'
 require 'rubygems'
-require 'activerecord'
+require 'active_record'
 require 'spec'
 
 module Spec::Example::ExampleGroupMethods
   alias :context :describe
 end
 
+class Array
+  def freq
+    k=Hash.new(0)
+    each {|e| k[e]+=1}
+    k
+  end
+end
+
 TEST_DATABASE_FILE = File.join(File.dirname(__FILE__), '..', 'test.sqlite3')
 
 File.unlink(TEST_DATABASE_FILE) if File.exist?(TEST_DATABASE_FILE)
@@ -16,18 +24,24 @@ ActiveRecord::Base.establish_connection(
 
 RAILS_DEFAULT_LOGGER = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
 
-load(File.dirname(__FILE__) + '/schema.rb')
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+  load(File.dirname(__FILE__) + '/schema.rb')
+end
 
 $: << File.join(File.dirname(__FILE__), '..', 'lib')
 require File.join(File.dirname(__FILE__), '..', 'init')
 
 class TaggableModel < ActiveRecord::Base
-  acts_as_taggable_on :tags, :languages
+  acts_as_taggable
+  acts_as_taggable_on :languages
   acts_as_taggable_on :skills
+  acts_as_taggable_on :needs, :offerings
 end
 
 class OtherTaggableModel < ActiveRecord::Base
   acts_as_taggable_on :tags, :languages
+  acts_as_taggable_on :needs, :offerings
 end
 
 class InheritingTaggableModel < TaggableModel

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-taggable-on
 version: !ruby/object:Gem::Version 
-  version: 1.0.12
+  version: 1.1.1
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-07 00:00:00 -05:00
+date: 2010-02-06 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -27,6 +27,8 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- generators/acts_as_taggable_on_migration/acts_as_taggable_on_migration_generator.rb
+- generators/acts_as_taggable_on_migration/templates/migration.rb
 - lib/acts-as-taggable-on.rb
 - lib/acts_as_taggable_on/acts_as_taggable_on.rb
 - lib/acts_as_taggable_on/acts_as_tagger.rb
@@ -44,6 +46,7 @@ files:
 - spec/acts_as_taggable_on/taggable_spec.rb
 - spec/acts_as_taggable_on/tagger_spec.rb
 - spec/acts_as_taggable_on/tagging_spec.rb
+- spec/acts_as_taggable_on/tags_helper_spec.rb
 - spec/schema.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -84,5 +87,6 @@ test_files:
 - spec/acts_as_taggable_on/taggable_spec.rb
 - spec/acts_as_taggable_on/tagger_spec.rb
 - spec/acts_as_taggable_on/tagging_spec.rb
+- spec/acts_as_taggable_on/tags_helper_spec.rb
 - spec/schema.rb
 - spec/spec_helper.rb