acts-as-taggable-on 2.1.1 → 2.2.0

data/.gitignore

@@ -5,3 +5,4 @@
 .rvmrc
 Gemfile.lock
 spec/database.yml
+tmp

data/.travis.yml

@@ -1,9 +1,8 @@
 script: "cp spec/database.yml.sample spec/database.yml && bundle install && bundle exec rake"
 rvm:
   - 1.8.7
-  - ree
   - 1.9.2
-  - rbx
+  - 1.9.3
 env:
   - DB=sqlite3
   - DB=mysql

data/README.rdoc

@@ -1,4 +1,5 @@
 = ActsAsTaggableOn
+{<img src="https://secure.travis-ci.org/mbleigh/acts-as-taggable-on.png" />}[http://travis-ci.org/mbleigh/acts-as-taggable-on]
 
 This plugin was originally based on Acts as Taggable on Steroids by Jonathan Viney.
 It has evolved substantially since that point, but all credit goes to him for the
@@ -17,34 +18,15 @@ was used.
 
 === Rails 2.3.x
 
-The last version of gem that is compatible with Rails 2.3.x is 2.1.0.
-
-We are planning no longer to support Rails 2, but if you want to contribute something only for Rails 2, we left rails2 branch for that.
-
-==== Plugin
-
-Acts As Taggable On is available both as a gem and as a traditional plugin. For the
-traditional plugin you can install like so:
-
-  script/plugin install git://github.com/mbleigh/acts-as-taggable-on.git
-
-Acts As Taggable On is also available as a gem plugin using Rails 2.1's gem dependencies.
-To install the gem, add this to your config/environment.rb:
-  
-  config.gem "acts-as-taggable-on", :source => "http://gemcutter.org", :version => '2.1.0'
-  
-After that, you can run "rake gems:install" to install the gem if you don't already have it.
+To use it, add it to your Gemfile:
 
-==== Post Installation
-
-1. script/generate acts_as_taggable_on_migration
-2. rake db:migrate
+  gem 'acts-as-taggable-on', '2.1.0'
 
 === Rails 3.x
 
 To use it, add it to your Gemfile:
-  
-  gem 'acts-as-taggable-on', '~>2.1.0'
+
+  gem 'acts-as-taggable-on'
 
 ==== Post Installation
 
@@ -87,7 +69,7 @@ compatibility with the will_paginate gem:
 
     class User < ActiveRecord::Base
       acts_as_taggable_on :tags, :skills
-      named_scope :by_join_date, :order => "created_at DESC"
+      scope :by_join_date, order("created_at DESC")
     end
 
     User.tagged_with("awesome").by_date
@@ -95,17 +77,19 @@ compatibility with the will_paginate gem:
 
     # Find a user with matching all tags, not just one
     User.tagged_with(["awesome", "cool"], :match_all => :true)
-    
+
     # Find a user with any of the tags:
     User.tagged_with(["awesome", "cool"], :any => true)
-    
+
     # Find a user with any of tags based on context:
     User.tagged_with(['awesome, cool'], :on => :tags, :any => true).tagged_with(['smart', 'shy'], :on => :skills, :any => true)
-    
+
+  Note: User.tagged_with([]) or '' will return [], but not all records.
+
 === Relationships
 
 You can find objects of the same type based on similar tags on certain contexts.
-Also, objects will be returned in descending order based on the total number of 
+Also, objects will be returned in descending order based on the total number of
 matched tags.
 
     @bobby = User.find_by_name("Bobby")
@@ -118,8 +102,8 @@ matched tags.
     @tom.skill_list # => ["hacking", "jogging", "diving"]
 
     @tom.find_related_skills # => [<User name="Bobby">,<User name="Frankie">]
-    @bobby.find_related_skills # => [<User name="Tom">] 
-    @frankie.find_related_skills # => [<User name="Tom">] 
+    @bobby.find_related_skills # => [<User name="Tom">]
+    @frankie.find_related_skills # => [<User name="Tom">]
 
 === Dynamic Tag Contexts
 
@@ -149,8 +133,10 @@ Tags can have owners:
     @some_user.tag(@some_photo, :with => "paris, normandy", :on => :locations)
     @some_user.owned_taggings
     @some_user.owned_tags
-    @some_photo.locations_from(@some_user)
-    
+    @some_photo.locations_from(@some_user) # => ["paris", "normandy"]
+    @some_photo.owner_tags_on(@some_user, :locations) # => [#<ActsAsTaggableOn::Tag id: 1, name: "paris">...]
+    @some_photo.owner_tags_on(nil, :locations) # => Ownerships equivalent to saying @some_photo.locations
+
 === Tag cloud calculations
 
 To construct tag clouds, the frequency of each tag needs to be calculated.
@@ -193,23 +179,14 @@ CSS:
 
 == Contributors
 
-* Artem Kramarenko (artemk) - Maintainer
-* TomEric (i76) - Maintainer
-* Michael Bleigh - Original Author
-* Szymon Nowak - Rails 3.0 compatibility
-* Jelle Vandebeeck - Rails 3.0 compatibility
-* Brendan Lim - Related Objects
-* Pradeep Elankumaran - Taggers
-* Sinclair Bain - Patch King
-
-=== Patch Contributors
-
-* tristanzdunn - Related objects of other classes
-* azabaj - Fixed migrate down
-* Peter Cooper - named_scope fix
-* slainer68 - STI fix
-* harrylove - migration instructions and fix-ups
-* lawrencepit - cached tag work
-* sobrinho - fixed tag_cloud helper
+We have a long list of valued contributors. {Check them all}[https://github.com/mbleigh/acts-as-taggable-on/contributors]
+
+== Maintainers
+
+* Artem Kramarenko (artemk)
+
+== Author
+
+* Michael Bleigh
 
 Copyright (c) 2007-2011 Michael Bleigh (http://mbleigh.com/) and Intridea Inc. (http://intridea.com/), released under the MIT license

data/acts-as-taggable-on.gemspec

@@ -4,16 +4,17 @@ require 'acts-as-taggable-on/version'
 Gem::Specification.new do |gem|
   gem.name = %q{acts-as-taggable-on}
   gem.authors = ["Michael Bleigh"]
-  gem.date = %q{2010-05-19}
+  gem.date = %q{2011-12-09}
   gem.description = %q{With ActsAsTaggableOn, you can tag a single model on several contexts, such as skills, interests, and awards. It also provides other advanced functionality.}
   gem.summary = "Advanced tagging for Rails."
   gem.email = %q{michael@intridea.com}
   gem.homepage      = ''
 
-  gem.add_runtime_dependency 'rails'
+  gem.add_runtime_dependency 'rails', '~> 3.1'
   gem.add_development_dependency 'rspec', '~> 2.5'
+  gem.add_development_dependency 'ammeter', '~> 0.1.3'
   gem.add_development_dependency 'sqlite3'
-  gem.add_development_dependency 'mysql2', '< 0.3'
+  gem.add_development_dependency 'mysql2', '~> 0.3.7'
   gem.add_development_dependency 'pg'
   gem.add_development_dependency 'guard'
   gem.add_development_dependency 'guard-rspec'

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

@@ -1,12 +1,9 @@
 require "active_record"
 require "active_record/version"
 require "action_view"
-RAILS_3 = ::ActiveRecord::VERSION::MAJOR >= 3
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
-require "acts_as_taggable_on/compatibility/active_record_backports" unless RAILS_3
-
 require "acts_as_taggable_on/utils"
 
 require "acts_as_taggable_on/acts_as_taggable_on"
@@ -16,7 +13,6 @@ require "acts_as_taggable_on/acts_as_taggable_on/cache"
 require "acts_as_taggable_on/acts_as_taggable_on/ownership"
 require "acts_as_taggable_on/acts_as_taggable_on/related"
 
-#require "acts_as_taggable_on/utils"
 require "acts_as_taggable_on/acts_as_tagger"
 require "acts_as_taggable_on/tag"
 require "acts_as_taggable_on/tag_list"

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

@@ -1,4 +1,4 @@
 module ActsAsTaggableOn
-  VERSION = '2.1.1'
+  VERSION = '2.2.0'
 end
 

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -28,20 +28,11 @@ module ActsAsTaggableOn
       tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
 
       if taggable?
-        if RAILS_3
-          self.tag_types = (self.tag_types + tag_types).uniq        
-        else
-          write_inheritable_attribute(:tag_types, (self.tag_types + tag_types).uniq)                  
-        end
+          self.tag_types = (self.tag_types + tag_types).uniq
       else
-        if RAILS_3
           class_attribute :tag_types
           self.tag_types = tag_types
-        else
-          write_inheritable_attribute(:tag_types, tag_types)
-          class_inheritable_reader(:tag_types)
-        end
-        
+
         class_eval do
           has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging"
           has_many :base_tags, :through => :taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
@@ -49,8 +40,8 @@ module ActsAsTaggableOn
           def self.taggable?
             true
           end
-          
-          include ActsAsTaggableOn::Utils        
+
+          include ActsAsTaggableOn::Utils
           include ActsAsTaggableOn::Taggable::Core
           include ActsAsTaggableOn::Taggable::Collection
           include ActsAsTaggableOn::Taggable::Cache

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -40,7 +40,7 @@ module ActsAsTaggableOn::Taggable
         tag_types.map(&:to_s).each do |tag_type|
           if self.class.send("caching_#{tag_type.singularize}_list?")
             if tag_list_cache_set_on(tag_type)
-              list = tag_list_cache_on(tag_type.singularize).to_a.flatten.compact.join(', ')
+              list = tag_list_cache_on(tag_type).to_a.flatten.compact.join(', ')
               self["cached_#{tag_type.singularize}_list"] = list
             end
           end

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -125,7 +125,7 @@ module ActsAsTaggableOn::Taggable
           tagging_scope = tagging_scope.group(group_by)
         end
 
-        tag_scope = tag_scope.joins("JOIN (#{tagging_scope.to_sql}) AS taggings ON taggings.tag_id = tags.id")
+        tag_scope = tag_scope.joins("JOIN (#{tagging_scope.to_sql}) AS #{ActsAsTaggableOn::Tagging.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id")
         tag_scope
       end
     end

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -1,5 +1,5 @@
 module ActsAsTaggableOn::Taggable
-  module Core    
+  module Core
     def self.included(base)
       base.send :include, ActsAsTaggableOn::Taggable::Core::InstanceMethods
       base.extend ActsAsTaggableOn::Taggable::Core::ClassMethods
@@ -8,10 +8,10 @@ module ActsAsTaggableOn::Taggable
         attr_writer :custom_contexts
         after_save :save_tags
       end
-      
+
       base.initialize_acts_as_taggable_on_core
     end
-    
+
     module ClassMethods
       def initialize_acts_as_taggable_on_core
         tag_types.map(&:to_s).each do |tags_type|
@@ -20,9 +20,9 @@ module ActsAsTaggableOn::Taggable
           context_tags     = tags_type.to_sym
 
           class_eval do
-            has_many context_taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging",
-            :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_type]
-            has_many context_tags, :through => context_taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
+                    has_many context_taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOn::Tagging",
+                    :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_type]
+                    has_many context_tags, :through => context_taggings, :source => :tag, :class_name => "ActsAsTaggableOn::Tag"
           end
 
           class_eval %(
@@ -38,14 +38,14 @@ module ActsAsTaggableOn::Taggable
               all_tags_list_on('#{tags_type}')
             end
           )
-        end        
+        end
       end
-      
+
       def acts_as_taggable_on(*args)
         super(*args)
         initialize_acts_as_taggable_on_core
       end
-      
+
       # 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(", ")
@@ -59,12 +59,14 @@ module ActsAsTaggableOn::Taggable
       #                       * <tt>:exclude</tt> - if set to true, return objects that are *NOT* tagged with the specified tags
       #                       * <tt>:any</tt> - if set to true, return objects that are tagged with *ANY* of the specified tags
       #                       * <tt>:match_all</tt> - if set to true, return objects that are *ONLY* tagged with the specified tags
+      #                       * <tt>:owned_by</tt> - return objects that are *ONLY* owned by the owner
       #
       # Example:
       #   User.tagged_with("awesome", "cool")                     # Users that are tagged with awesome and cool
       #   User.tagged_with("awesome", "cool", :exclude => true)   # Users that are not tagged with awesome or cool
       #   User.tagged_with("awesome", "cool", :any => true)       # Users that are tagged with awesome or cool
       #   User.tagged_with("awesome", "cool", :match_all => true) # Users that are tagged with just awesome and cool
+      #   User.tagged_with("awesome", "cool", :owned_by => foo ) # Users that are tagged with just awesome and cool by 'foo'
       def tagged_with(tags, options = {})
         tag_list = ActsAsTaggableOn::TagList.from(tags)
         empty_result = scoped(:conditions => "1 = 0")
@@ -75,11 +77,12 @@ module ActsAsTaggableOn::Taggable
         conditions = []
 
         context = options.delete(:on)
+        owned_by = options.delete(:owned_by)
         alias_base_name = undecorated_table_name.gsub('.','_')
 
         if options.delete(:exclude)
           tags_conditions = tag_list.map { |t| sanitize_sql(["#{ActsAsTaggableOn::Tag.table_name}.name #{like_operator} ?", t]) }.join(" OR ")
-          conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
+          conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
 
         elsif options.delete(:any)
           # get tags, drop out if nothing returned (we need at least one)
@@ -89,7 +92,7 @@ module ActsAsTaggableOn::Taggable
           # setup taggings alias so we can chain, ex: items_locations_taggings_awesome_cool_123
           # avoid ambiguous column name
           taggings_context = context ? "_#{context}" : ''
-          
+
           #TODO: fix alias to be smaller
           taggings_alias   = "#{alias_base_name}#{taggings_context}_taggings_#{tags.map(&:safe_name).join('_')}_#{rand(1024)}"
 
@@ -119,6 +122,15 @@ module ActsAsTaggableOn::Taggable
                             " AND #{taggings_alias}.tag_id = #{tag.id}"
             tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
+            if owned_by
+                tagging_join << " AND " +
+                    sanitize_sql([
+                        "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
+                        owned_by.id,
+                        owned_by.class.to_s
+                    ])
+            end
+
             joins << tagging_join
           end
         end
@@ -146,8 +158,8 @@ module ActsAsTaggableOn::Taggable
       def is_taggable?
         true
       end
-    end    
-    
+    end
+
     module InstanceMethods
       # all column names are necessary for PostgreSQL group clause
       def grouped_column_names_for(object)
@@ -200,7 +212,7 @@ module ActsAsTaggableOn::Taggable
 
         opts  =  ["#{tagging_table_name}.context = ?", context.to_s]
         scope = base_tags.where(opts)
-        
+
         if ActsAsTaggableOn::Tag.using_postgresql?
           group_columns = grouped_column_names_for(ActsAsTaggableOn::Tag)
           scope = scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
@@ -233,7 +245,7 @@ module ActsAsTaggableOn::Taggable
           instance_variable_set("@#{context.to_s.singularize}_list", nil)
           instance_variable_set("@all_#{context.to_s.singularize}_list", nil)
         end
-      
+
         super(*args)
       end
 
@@ -249,14 +261,14 @@ module ActsAsTaggableOn::Taggable
           current_tags = tags_on(context)
           old_tags     = current_tags - tag_list
           new_tags     = tag_list     - current_tags
-          
+
           # Find taggings to remove:
           old_taggings = taggings.where(:tagger_type => nil, :tagger_id => nil,
                                         :context => context.to_s, :tag_id => old_tags).all
 
           if old_taggings.present?
             # Destroy old taggings:
-            ActsAsTaggableOn::Tagging.destroy_all :id => old_taggings.map(&:id)
+            ActsAsTaggableOn::Tagging.destroy_all "#{ActsAsTaggableOn::Tagging.primary_key}".to_sym => old_taggings.map(&:id)
           end
 
           # Create new taggings:

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -5,7 +5,7 @@ module ActsAsTaggableOn::Taggable
       base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
       base.initialize_acts_as_taggable_on_related
     end
-    
+
     module ClassMethods
       def initialize_acts_as_taggable_on_related
         tag_types.map(&:to_s).each do |tag_type|
@@ -20,7 +20,7 @@ module ActsAsTaggableOn::Taggable
             end
           )
         end
-        
+
         unless tag_types.empty?
           class_eval %(
             def find_matching_contexts(search_context, result_context, options = {})
@@ -31,43 +31,43 @@ module ActsAsTaggableOn::Taggable
               matching_contexts_for(search_context.to_s, result_context.to_s, klass, options)
             end
           )
-        end        
+        end
       end
-      
+
       def acts_as_taggable_on(*args)
         super(*args)
         initialize_acts_as_taggable_on_related
       end
     end
-    
+
     module InstanceMethods
       def matching_contexts_for(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
-        
+        exclude_self = "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
+
         group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
-        
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.id) AS count",
+
+        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count",
                        :from       => "#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context],
+                       :conditions => ["#{exclude_self} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context],
                        :group      => group_columns,
                        :order      => "count DESC" }.update(options))
       end
-      
+
       def related_tags_for(context, klass, options = {})
         tags_to_find = tags_on(context).collect { |t| t.name }
 
-        exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
+        exclude_self = "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
 
 group_columns = ActsAsTaggableOn::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
 
-        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.id) AS count",
+        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count",
                        :from       => "#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}",
-                       :conditions => ["#{exclude_self} #{klass.table_name}.id = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?)", tags_to_find],
+                       :conditions => ["#{exclude_self} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class.to_s}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?)", tags_to_find],
                        :group      => group_columns,
                        :order      => "count DESC" }.update(options))
       end
     end
   end
-end
+end