acts-as-taggable-on 2.3.3 → 2.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0b7cd2b4e279238a0fb8464721b40c3dbedaacd
+  data.tar.gz: edd07332dcbd884be1daab9e65d9be28b6f3f695
+SHA512:
+  metadata.gz: 65f468a535ce620033df88d152bd5e1bff722c01a197d233794da097e682b29ad5f4ebf46b4eb46a18957d2ecda9f6699aad27b42789a2c8ee8d7c4f68e985ba
+  data.tar.gz: 2fd5249aa31f826fd56666dd3d07c4a63df1803722fc7e29c02b39fdbff6f0459316f30a1bb9345c53e885fa5a0edfd30495e211e8e6e90630600d9d60cd69a5

data/.gitignore

@@ -2,10 +2,10 @@
 *.sqlite3
 /pkg/*
 .bundle
-.rvmrc
-Gemfile.lock
+.ruby-version
 spec/database.yml
 tmp*.sw?
 *.sw?
 tmp
-*.gem
+*.gem
+*.lock

data/Appraisals

@@ -0,0 +1,7 @@
+appraise "rails-3" do
+  gem "rails", "3.2.13"
+end
+
+appraise "rails-4" do
+  gem "rails", "4.0.0.beta1"
+end

data/Gemfile

@@ -1,3 +1,5 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
+
 gemspec
 
+gem 'appraisal'

data/{MIT-LICENSE → LICENSE.md}

@@ -1,4 +1,4 @@
-Copyright (c) 2007 Michael Bleigh and Intridea Inc.
+__Copyright (c) 2007 Michael Bleigh and Intridea Inc.__
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,303 @@
+# ActsAsTaggableOn
+[![Build Status](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
+initial tagging functionality that so many people have used.
+
+For instance, in a social network, a user might have tags that are called skills,
+interests, sports, and more. There is no real way to differentiate between tags and
+so an implementation of this type is not possible with acts as taggable on steroids.
+
+Enter Acts as Taggable On. Rather than tying functionality to a specific keyword
+(namely `tags`), acts as taggable on allows you to specify an arbitrary number of
+tag "contexts" that can be used locally or in combination in the same way steroids
+was used.
+
+## Compatibility
+
+Versions 2.x are compatible with Ruby 1.8.7+ and Rails 3.
+
+Versions 2.4.1 and up are compatible with Rails 4 too (thanks to arabonradar and cwoodcox).
+
+Versions 3.x (currently unreleased) are compatible with Ruby 1.9.3+ and Rails 3 and 4.
+
+For an up-to-date roadmap, see https://github.com/mbleigh/acts-as-taggable-on/issues/milestones
+
+## Installation
+
+To use it, add it to your Gemfile:
+
+```ruby
+gem 'acts-as-taggable-on'
+```
+
+and bundle:
+
+```ruby
+bundle
+```
+
+#### Post Installation
+
+```shell
+rails generate acts_as_taggable_on:migration
+rake db:migrate
+```
+
+## Testing
+
+Acts As Taggable On uses RSpec for its test coverage. Inside the gem
+directory, you can run the specs with:
+
+```shell
+bundle
+rake spec
+```
+
+If you want, add a `.ruby-version` file in the project root (and use rbenv or RVM) to work on a specific version of Ruby.
+
+## Usage
+
+```ruby
+class User < ActiveRecord::Base
+  # Alias for acts_as_taggable_on :tags
+  acts_as_taggable
+  acts_as_taggable_on :skills, :interests
+end
+
+@user = User.new(:name => "Bobby")
+@user.tag_list = "awesome, slick, hefty"      # this should be familiar
+@user.skill_list = "joking, clowning, boxing" # but you can do it for any context!
+
+@user.tags                                    # => [<Tag name:"awesome">,<Tag name:"slick">,<Tag name:"hefty">]
+@user.skills                                  # => [<Tag name:"joking">,<Tag name:"clowning">,<Tag name:"boxing">]
+@user.skill_list                              # => ["joking","clowning","boxing"] as TagList
+
+@user.tag_list.remove("awesome")              # remove a single tag
+@user.tag_list.remove("awesome, slick")       # works with arrays too
+@user.tag_list.add("awesomer")                # add a single tag. alias for <<
+@user.tag_list.add("awesomer, slicker")       # also works with arrays
+
+User.skill_counts                             # => [<Tag name="joking" count=2>,<Tag name="clowning" count=1>...]
+```
+
+To preserve the order in which tags are created use `acts_as_ordered_taggable`:
+
+```ruby
+class User < ActiveRecord::Base
+  # Alias for acts_as_ordered_taggable_on :tags
+  acts_as_ordered_taggable
+  acts_as_ordered_taggable_on :skills, :interests
+end
+
+@user = User.new(:name => "Bobby")
+@user.tag_list = "east, south"
+@user.save
+
+@user.tag_list = "north, east, south, west"
+@user.save
+
+@user.reload
+@user.tag_list # => ["north", "east", "south", "west"]
+```
+
+### Finding Tagged Objects
+
+Acts As Taggable On uses scopes to create an association for tags.
+This way you can mix and match to filter down your results.
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_taggable_on :tags, :skills
+  scope :by_join_date, order("created_at DESC")
+end
+
+User.tagged_with("awesome").by_join_date
+User.tagged_with("awesome").by_join_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)
+
+# Find a user with any of the tags:
+User.tagged_with(["awesome", "cool"], :any => true)
+
+# Find a user that not tags with awesome or cool:
+User.tagged_with(["awesome", "cool"], :exclude => 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)
+```
+
+You can also use `:wild => true` option along with `:any` or `:exclude` option. It will looking for `%awesome%` and `%cool%` in sql.
+
+__Tip:__ `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
+matched tags.
+
+```ruby
+@bobby = User.find_by_name("Bobby")
+@bobby.skill_list # => ["jogging", "diving"]
+
+@frankie = User.find_by_name("Frankie")
+@frankie.skill_list # => ["hacking"]
+
+@tom = User.find_by_name("Tom")
+@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">]
+```
+
+### Dynamic Tag Contexts
+
+In addition to the generated tag contexts in the definition, it is also possible
+to allow for dynamic tag contexts (this could be user generated tag contexts!)
+
+```ruby
+@user = User.new(:name => "Bobby")
+@user.set_tag_list_on(:customs, "same, as, tag, list")
+@user.tag_list_on(:customs) # => ["same","as","tag","list"]
+@user.save
+@user.tags_on(:customs) # => [<Tag name='same'>,...]
+@user.tag_counts_on(:customs)
+User.tagged_with("same", :on => :customs) # => [@user]
+```
+
+### Tag Ownership
+
+Tags can have owners:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_tagger
+end
+
+class Photo < ActiveRecord::Base
+  acts_as_taggable_on :locations
+end
+
+@some_user.tag(@some_photo, :with => "paris, normandy", :on => :locations)
+@some_user.owned_taggings
+@some_user.owned_tags
+Photo.tagged_with("paris", :on => :locations, :owned_by => @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
+@some_user.tag(@some_photo, :with => "paris, normandy", :on => :locations, :skip_save => true) #won't save @some_photo object
+```
+
+### Dirty objects
+
+```ruby
+@bobby = User.find_by_name("Bobby")
+@bobby.skill_list # => ["jogging", "diving"]
+
+@bobby.skill_list_changed? #=> false
+@bobby.changes #=> {}
+
+@bobby.skill_list = "swimming"
+@bobby.changes.should == {"skill_list"=>["jogging, diving", ["swimming"]]}
+@bobby.skill_list_changed? #=> true
+
+@bobby.skill_list_change.should == ["jogging, diving", ["swimming"]]
+```
+
+### 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 `User` class, we can
+get a calculation of all the tag counts by using `User.tag_counts_on(:customs)`. But what if we wanted a tag count for
+an single user's posts? To achieve this we call tag_counts on the association:
+
+```ruby
+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:
+
+```ruby
+module PostsHelper
+  include ActsAsTaggableOn::TagsHelper
+end
+```
+
+Controller:
+
+```ruby
+class PostController < ApplicationController
+  def tag_cloud
+    @tags = Post.tag_counts_on(:tags)
+  end
+end
+```
+
+View:
+
+```erb
+<% 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:
+
+```css
+.css1 { font-size: 1.0em; }
+.css2 { font-size: 1.2em; }
+.css3 { font-size: 1.4em; }
+.css4 { font-size: 1.6em; }
+```
+
+## Configuration
+
+If you would like to remove unused tag objects after removing taggings, add:
+
+```ruby
+ActsAsTaggableOn.remove_unused_tags = true
+```
+
+If you want force tags to be saved downcased:
+
+```ruby
+ActsAsTaggableOn.force_lowercase = true
+```
+
+If you want tags to be saved parametrized (you can redefine to_param as well):
+
+```ruby
+ActsAsTaggableOn.force_parameterize = true
+```
+
+If you would like tags to be case-sensitive and not use LIKE queries for creation:
+
+```ruby
+ActsAsTaggableOn.strict_case_match = true
+```
+
+If you want to change the default delimiter (it defaults to ','). You can also pass in an array of delimiters such as ([',', '|']):
+
+```ruby
+ActsAsTaggableOn.delimiter = ','
+```
+
+## Contributors
+
+We have a long list of valued contributors. [Check them all](https://github.com/mbleigh/acts-as-taggable-on/contributors)
+
+## Maintainer
+
+* [Joost Baaij](https://github.com/tilsammans)
+
+## License
+
+See [LICENSE](https://github.com/mbleigh/acts-as-taggable-on/blob/master/LICENSE.md)

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rubygems'
-require 'bundler'
-Bundler.setup :default, :development
+require 'bundler/setup'
+require 'appraisal'
 
 desc 'Default: run specs'
 task :default => :spec  

data/acts-as-taggable-on.gemspec

@@ -1,28 +1,35 @@
-$:.push File.dirname(__FILE__) + '/lib'
-require 'acts-as-taggable-on/version'
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+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{2012-07-16}
-  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.name          = "acts-as-taggable-on"
+  gem.version       = ActsAsTaggableOn::VERSION
+  gem.authors       = ["Michael Bleigh", "Joost Baaij"]
+  gem.email         = ["michael@intridea.com", "joost@spacebabies.nl"]
+  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.homepage      = 'https://github.com/mbleigh/acts-as-taggable-on'
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  if File.exists?('UPGRADING')
+    gem.post_install_message = File.read('UPGRADING')
+  end
 
-  gem.add_runtime_dependency 'rails', '~> 3.0'
+  gem.add_runtime_dependency 'rails', ['>= 3', '< 5']
+
+  gem.add_development_dependency 'rspec-rails', '2.13.0' # 2.13.1 is broken
   gem.add_development_dependency 'rspec', '~> 2.6'
-  gem.add_development_dependency 'ammeter', '~> 0.1.3'
+  gem.add_development_dependency 'ammeter'
   gem.add_development_dependency 'sqlite3'
   gem.add_development_dependency 'mysql2', '~> 0.3.7'
   gem.add_development_dependency 'pg'
   gem.add_development_dependency 'guard'
   gem.add_development_dependency 'guard-rspec'
-
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  gem.files         = `git ls-files`.split("\n")
-  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.name          = "acts-as-taggable-on"
-  gem.require_paths = ['lib']
-  gem.version       = ActsAsTaggableOn::VERSION
 end

data/gemfiles/rails_3.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "rails", "3.2.13"
+
+gemspec :path=>"../"

data/gemfiles/rails_4.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "rails", :github => 'rails/rails'
+
+gemspec :path=>"../"

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

@@ -16,6 +16,9 @@ module ActsAsTaggableOn
   mattr_accessor :force_parameterize
   @@force_parameterize = false
 
+  mattr_accessor :strict_case_match
+  @@strict_case_match = false
+
   mattr_accessor :remove_unused_tags
   self.remove_unused_tags = false
 
@@ -33,6 +36,7 @@ end
 require "acts_as_taggable_on/utils"
 
 require "acts_as_taggable_on/taggable"
+require "acts_as_taggable_on/acts_as_taggable_on/compatibility"
 require "acts_as_taggable_on/acts_as_taggable_on/core"
 require "acts_as_taggable_on/acts_as_taggable_on/collection"
 require "acts_as_taggable_on/acts_as_taggable_on/cache"
@@ -50,6 +54,7 @@ $LOAD_PATH.shift
 
 
 if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.extend ActsAsTaggableOn::Compatibility
   ActiveRecord::Base.extend ActsAsTaggableOn::Taggable
   ActiveRecord::Base.send :include, ActsAsTaggableOn::Tagger
 end

data/lib/acts_as_taggable_on/acts_as_taggable_on/cache.rb

@@ -17,11 +17,11 @@ module ActsAsTaggableOn::Taggable
     module ClassMethods
       def initialize_acts_as_taggable_on_cache      
         tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def self.caching_#{tag_type.singularize}_list?
               caching_tag_list_on?("#{tag_type}")
             end        
-          )
+          RUBY
         end        
       end
       

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -9,7 +9,7 @@ module ActsAsTaggableOn::Taggable
     module ClassMethods
       def initialize_acts_as_taggable_on_collection
         tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def self.#{tag_type.singularize}_counts(options={})
               tag_counts_on('#{tag_type}', options)
             end
@@ -25,7 +25,7 @@ module ActsAsTaggableOn::Taggable
             def self.top_#{tag_type}(limit = 10)
               tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
             end        
-          )
+          RUBY
         end        
       end
       
@@ -37,6 +37,60 @@ module ActsAsTaggableOn::Taggable
       def tag_counts_on(context, options = {})
         all_tag_counts(options.merge({:on => context.to_s}))
       end
+
+      def tags_on(context, options = {})
+        all_tags(options.merge({:on => context.to_s}))
+      end
+
+      ##
+      # Calculate the tag names.
+      # To be used when you don't need tag counts and want to avoid the taggable joins.
+      #
+      # @param [Hash] options Options:
+      #                       * :start_at   - Restrict the tags to those created after a certain time
+      #                       * :end_at     - Restrict the tags to those created before a certain time
+      #                       * :conditions - A piece of SQL conditions to add to the query. Note we don't join the taggable objects for performance reasons.
+      #                       * :limit      - The maximum number of tags to return
+      #                       * :order      - A piece of SQL to order by. Eg 'tags.count desc' or 'taggings.created_at desc'
+      #                       * :on         - Scope the find to only include a certain context
+      def all_tags(options = {})
+        options.assert_valid_keys :start_at, :end_at, :conditions, :order, :limit, :on
+
+        ## Generate conditions:
+        options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
+
+        start_at_conditions = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+        end_at_conditions   = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?", options.delete(:end_at)])   if options[:end_at]
+
+        taggable_conditions  = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.taggable_type = ?", base_class.name])
+        taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
+
+        tagging_conditions = [
+          taggable_conditions,
+          start_at_conditions,
+          end_at_conditions
+        ].compact.reverse
+
+        tag_conditions = [
+          options[:conditions]
+        ].compact.reverse
+
+        ## Generate scope:
+        tagging_scope = ActsAsTaggableOn::Tagging.select("#{ActsAsTaggableOn::Tagging.table_name}.tag_id")
+        tag_scope = ActsAsTaggableOn::Tag.select("#{ActsAsTaggableOn::Tag.table_name}.*").order(options[:order]).limit(options[:limit])
+
+        # Joins and conditions
+        tagging_conditions.each { |condition| tagging_scope = tagging_scope.where(condition) }
+        tag_conditions.each     { |condition| tag_scope     = tag_scope.where(condition)     }
+
+        group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
+
+        # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
+        ids = select("#{table_name}.#{primary_key}").map(&:id)
+        tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(?)", ids).group(group_columns)
+        
+        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")
+      end
       
       ##
       # Calculate the tag counts for all tags.
@@ -100,18 +154,21 @@ module ActsAsTaggableOn::Taggable
         tag_conditions.each     { |condition| tag_scope     = tag_scope.where(condition)     }
 
         # GROUP BY and HAVING clauses:
-        at_least  = sanitize_sql(['tags_count >= ?', options.delete(:at_least)]) if options[:at_least]
-        at_most   = sanitize_sql(['tags_count <= ?', options.delete(:at_most)]) if options[:at_most]
+        at_least  = sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) >= ?", options.delete(:at_least)]) if options[:at_least]
+        at_most   = sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) <= ?", options.delete(:at_most)]) if options[:at_most]
         having    = ["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) > 0", at_least, at_most].compact.join(' AND ')    
 
         group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
 
         # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
         scoped_select = "#{table_name}.#{primary_key}"
-        tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{select(scoped_select).to_sql})").
-                                      group(group_columns).
-                                      having(having)
+        select_query = "#{select(scoped_select).to_sql}"
+
+        res = ActiveRecord::Base.connection.select_all(select_query).map { |item| item.values }.flatten.compact.join(",")
+        res = "NULL" if res.blank?
 
+        tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{res})")
+        tagging_scope = tagging_scope.group(group_columns).having(having)
 
         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

data/lib/acts_as_taggable_on/acts_as_taggable_on/compatibility.rb

@@ -0,0 +1,34 @@
+module ActsAsTaggableOn::Compatibility
+  def has_many_with_compatibility(name, options = {}, &extention)
+    if ActiveRecord::VERSION::MAJOR >= 4
+      scope, opts = build_scope_and_options(options)
+      has_many(name, scope, opts, &extention)
+    else
+      has_many(name, options, &extention)
+    end
+  end
+
+  def build_scope_and_options(opts)
+    scope_opts, opts = parse_options(opts)
+
+    unless scope_opts.empty?
+      scope = lambda do 
+        scope_opts.inject(self) { |result, hash| result.send *hash }
+      end
+    end
+
+    [defined?(scope) ? scope : nil, opts]
+  end
+
+  def parse_options(opts)
+    scope_opts = {}
+    [:order, :having, :select, :group, :limit, :offset, :readonly].each do |o|
+      scope_opts[o] = opts.delete o if opts[o]
+    end
+    scope_opts[:where] = opts.delete :conditions if opts[:conditions]
+    scope_opts[:joins] = opts.delete :include if opts [:include]
+    scope_opts[:distinct] = opts.delete :uniq if opts[:uniq]
+
+    [scope_opts, opts]
+  end
+end