rylwin-acts-as-taggable-on 2.1.1a

data/.gitignore

@@ -0,0 +1,8 @@
+*.log
+*.sqlite3
+/pkg/*
+.bundle
+.rvmrc
+Gemfile.lock
+spec/database.yml
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--backtrace

data/.travis.yml

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

data/CHANGELOG

@@ -0,0 +1,35 @@
+== 2011-08-21
+* escape _ and % for mysql and postgres (@tilsammans)
+* Now depends on mysql2 gem
+* tagged_with :any is chainable now (@jeffreyiacono)
+* tagged_with(nil) returns scoped object
+* Case-insensitivity for TaggedModel.tagged_with for PostgreSQL database
+* tagged_with(' ') returns scoped object
+* remove warning for rails 3.1 about class_inheritable_attribute
+* use ActiveRecord migration_number to avoid clashs (@atd)
+
+== 2010-02-17
+* Converted the plugin to be compatible with Rails3
+
+== 2009-12-02
+
+* PostgreSQL is now supported (via morgoth)
+
+== 2008-07-17
+
+* Can now use a named_scope to find tags!
+
+== 2008-06-23
+
+* Can now find related objects of another class (tristanzdunn)
+* Removed extraneous down migration cruft (azabaj)
+
+== 2008-06-09
+
+ * Added support for Single Table Inheritance
+ * Adding gemspec and rails/init.rb for gemified plugin
+
+== 2007-12-12
+
+ * Added ability to use dynamic tag contexts
+ * Fixed missing migration generator

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+gemspec
+

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+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
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,222 @@
+= ActsAsTaggableOn
+
+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.
+
+== Installation
+
+=== 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.
+
+==== Post Installation
+
+1. script/generate acts_as_taggable_on_migration
+2. rake db:migrate
+
+=== Rails 3.x
+
+To use it, add it to your Gemfile:
+  
+  gem 'acts-as-taggable-on', '~>2.1.0'
+
+==== Post Installation
+
+1. rails generate acts_as_taggable_on:migration
+2. rake db:migrate
+
+== Testing
+
+Acts As Taggable On uses RSpec for its test coverage. Inside the gem
+directory, you can run the specs for RoR 3.x with:
+
+  rake spec
+
+== Usage
+
+    class User < ActiveRecord::Base
+      # Alias for <tt>acts_as_taggable_on :tags</tt>:
+      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.skill_list                              # => ["joking","clowning","boxing"] as TagList
+    @user.save
+
+    @user.tags # => [<Tag name:"awesome">,<Tag name:"slick">,<Tag name:"hefty">]
+    @user.skills # => [<Tag name:"joking">,<Tag name:"clowning">,<Tag name:"boxing">]
+
+    @frankie = User.create(:name => "Frankie", :skill_list => "joking, flying, eating")
+    User.skill_counts # => [<Tag name="joking" count=2>,<Tag name="clowning" count=1>...]
+    @frankie.skill_counts
+
+=== Finding Tagged Objects
+
+Acts As Taggable On utilizes named_scopes to create an association for tags.
+This way you can mix and match to filter down your results, and it also improves
+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"
+    end
+
+    User.tagged_with("awesome").by_date
+    User.tagged_with("awesome").by_date.paginate(:page => params[:page], :per_page => 20)
+
+    # Find a user with matching all tags, not just one
+    User.tagged_with(["awesome", "cool"], :match_all => :true)
+    
+    # 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)
+    
+=== 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.
+
+    @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!)
+
+    @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:
+
+    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
+    @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.
+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 ActsAsTaggableOn::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; }
+
+== Why TaggableModel.joins(:tags) doesn't work (only for Rails >=3.0.10)?
+
+When you define acts_as_taggable_on in your model it add <tt>has_many :through</tt> associations to your model. In this +has_many+ declaration we join 'tags' table using rails ":include" statement, also we use additional ":conditions" statement where we refer to joined 'tags' table. In rails 3.0.10 they changed logic, and {now}[https://github.com/rails/rails/commit/caec63929fabe0368da71128c96e74c174791eb9] <tt>joins</tt> which is mode on model, substitutes 'include' from has_many declaration and place 'joins' at the end of sql, after 'conditions'. So Joining is happened but after 'Where'. 
+While we are trying to figure out how to fix this, please use Rails 3.0.9 or don't use Model.joins(:tags)
+
+== 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
+
+Copyright (c) 2007-2011 Michael Bleigh (http://mbleigh.com/) and Intridea Inc. (http://intridea.com/), released under the MIT license

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development
+
+desc 'Default: run specs'
+task :default => :spec  
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+Bundler::GemHelper.install_tasks

data/acts-as-taggable-on.gemspec

@@ -0,0 +1,28 @@
+$:.push File.dirname(__FILE__) + '/lib'
+require 'acts-as-taggable-on/version'
+
+Gem::Specification.new do |gem|
+  gem.name = %q{rylwin-acts-as-taggable-on}
+  gem.authors = ["Michael Bleigh", "Ryan Winograd"]
+  gem.date = %q{2010-05-19}
+  gem.description = %q{ActsAsTaggableOn, with Expected /lib/acts_as_taggable_on/acts_as_taggable_on.rb to define ActsAsTaggableOn::ActsAsTaggableOn fixed as described by rymai (https://github.com/mbleigh/acts-as-taggable-on/issues/79#issuecomment-262073).}
+  gem.summary = "Advanced tagging for Rails."
+  gem.email = %q{ryan@thewinograds.com}
+  gem.homepage      = ''
+
+  gem.add_runtime_dependency 'rails'
+  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 '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          = "rylwin-acts-as-taggable-on"
+  gem.require_paths = ['lib']
+  gem.version       = ActsAsTaggableOn::VERSION
+end

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/version.rb

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

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

@@ -0,0 +1,36 @@
+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/taggable"
+require "acts_as_taggable_on/taggable/core"
+require "acts_as_taggable_on/taggable/collection"
+require "acts_as_taggable_on/taggable/cache"
+require "acts_as_taggable_on/taggable/ownership"
+require "acts_as_taggable_on/taggable/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"
+require "acts_as_taggable_on/tags_helper"
+require "acts_as_taggable_on/tagging"
+
+$LOAD_PATH.shift
+
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.extend ActsAsTaggableOn::Taggable
+  ActiveRecord::Base.send :include, ActsAsTaggableOn::Tagger
+end
+
+if defined?(ActionView::Base)
+  ActionView::Base.send :include, ActsAsTaggableOn::TagsHelper
+end

data/lib/acts_as_taggable_on/acts_as_tagger.rb

@@ -0,0 +1,67 @@
+module ActsAsTaggableOn
+  module Tagger
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      ##
+      # Make a model a tagger. This allows an instance of a model to claim ownership
+      # of tags.
+      #
+      # Example:
+      #   class User < ActiveRecord::Base
+      #     acts_as_tagger
+      #   end
+      def acts_as_tagger(opts={})
+        class_eval do
+          has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy,
+                                               :include => :tag, :class_name => "ActsAsTaggableOn::Tagging")
+          has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true, :class_name => "ActsAsTaggableOn::Tag"
+        end
+
+        include ActsAsTaggableOn::Tagger::InstanceMethods
+        extend ActsAsTaggableOn::Tagger::SingletonMethods
+      end
+
+      def is_tagger?
+        false
+      end
+    end
+
+    module InstanceMethods
+      ##
+      # Tag a taggable model with tags that are owned by the tagger. 
+      #
+      # @param taggable The object that will be tagged
+      # @param [Hash] options An hash with options. Available options are:
+      #               * <tt>:with</tt> - The tags that you want to
+      #               * <tt>:on</tt>   - The context on which you want to tag
+      #
+      # Example:
+      #   @user.tag(@photo, :with => "paris, normandy", :on => :locations)
+      def tag(taggable, opts={})
+        opts.reverse_merge!(:force => true)
+
+        return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
+
+        raise "You need to specify a tag context using :on"                unless opts.has_key?(:on)
+        raise "You need to specify some tags using :with"                  unless opts.has_key?(:with)
+        raise "No context :#{opts[:on]} defined in #{taggable.class.to_s}" unless (opts[:force] || taggable.tag_types.include?(opts[:on]))
+
+        taggable.set_owner_tag_list_on(self, opts[:on].to_s, opts[:with])
+        taggable.save
+      end
+
+      def is_tagger?
+        self.class.is_tagger?
+      end
+    end
+
+    module SingletonMethods
+      def is_tagger?
+        true
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/compatibility/Gemfile

@@ -0,0 +1,8 @@
+source :gemcutter
+
+# Rails 2.3
+gem 'rails',        '2.3.5'
+gem 'rspec',        '1.3.0', :require => 'spec'
+gem 'sqlite3-ruby', '1.2.5', :require => 'sqlite3'
+gem 'mysql2',       '~> 0.2.7'
+gem 'pg'

data/lib/acts_as_taggable_on/compatibility/active_record_backports.rb

@@ -0,0 +1,21 @@
+module ActsAsTaggableOn
+  module ActiveRecord
+    module Backports
+      def self.included(base)
+        base.class_eval do
+          named_scope :where,    lambda { |conditions| { :conditions => conditions } }  
+          named_scope :joins,    lambda { |joins|      { :joins => joins } }
+          named_scope :group,    lambda { |group|      { :group => group } }
+          named_scope :order,    lambda { |order|      { :order => order } }
+          named_scope :select,   lambda { |select|     { :select => select } }
+          named_scope :limit,    lambda { |limit|      { :limit => limit } }
+          named_scope :readonly, lambda { |readonly|   { :readonly => readonly } }
+          
+          def self.to_sql
+            construct_finder_sql({})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/tag.rb

@@ -0,0 +1,81 @@
+module ActsAsTaggableOn
+  class Tag < ::ActiveRecord::Base
+    include ActsAsTaggableOn::ActiveRecord::Backports if ::ActiveRecord::VERSION::MAJOR < 3
+    include ActsAsTaggableOn::Utils
+      
+    attr_accessible :name
+
+    ### ASSOCIATIONS:
+
+    has_many :taggings, :dependent => :destroy, :class_name => 'ActsAsTaggableOn::Tagging'
+
+    ### VALIDATIONS:
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+
+    ### SCOPES:
+    
+    def self.named(name)
+      where(["name #{like_operator} ?", escape_like(name)])
+    end
+  
+    def self.named_any(list)
+      where(list.map { |tag| sanitize_sql(["name #{like_operator} ?", escape_like(tag.to_s)]) }.join(" OR "))
+    end
+  
+    def self.named_like(name)
+      where(["name #{like_operator} ?", "%#{escape_like(name)}%"])
+    end
+
+    def self.named_like_any(list)
+      where(list.map { |tag| sanitize_sql(["name #{like_operator} ?", "%#{escape_like(tag.to_s)}%"]) }.join(" OR "))
+    end
+
+    ### CLASS METHODS:
+
+    def self.find_or_create_with_like_by_name(name)
+      named_like(name).first || create(:name => name)
+    end
+
+    def self.find_or_create_all_with_like_by_name(*list)
+      list = [list].flatten
+
+      return [] if list.empty?
+
+      existing_tags = Tag.named_any(list).all
+      new_tag_names = list.reject do |name| 
+                        name = comparable_name(name)
+                        existing_tags.any? { |tag| comparable_name(tag.name) == name }
+                      end
+      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
+
+    def to_s
+      name
+    end
+
+    def count
+      read_attribute(:count).to_i
+    end
+    
+    def safe_name
+      name.gsub(/[^a-zA-Z0-9]/, '')
+    end
+    
+    class << self
+      private        
+        def comparable_name(str)
+          RUBY_VERSION >= "1.9" ? str.downcase : str.mb_chars.downcase
+        end
+    end
+  end
+end