acts-as-taggable-on 2.0.0.pre5 → 3.5.0

data/lib/acts_as_taggable_on/acts_as_taggable_on/ownership.rb

@@ -1,101 +0,0 @@
-module ActsAsTaggableOn::Taggable
-  module Ownership
-    def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Ownership::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
-     
-      base.class_eval do
-        after_save :save_owned_tags    
-      end
-      
-      base.initialize_acts_as_taggable_on_ownership
-    end
-    
-    module ClassMethods
-      def acts_as_taggable_on(*args)
-        initialize_acts_as_taggable_on_ownership
-        super(*args)
-      end
-      
-      def initialize_acts_as_taggable_on_ownership      
-        tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
-            def #{tag_type}_from(owner)
-              owner_tag_list_on(owner, '#{tag_type}')
-            end      
-          )
-        end        
-      end
-    end
-    
-    module InstanceMethods
-      def owner_tags_on(owner, context)
-        base_tags.where([%(#{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]).all
-      end
-
-      def cached_owned_tag_list_on(context)
-        variable_name = "@owned_#{context}_list"
-        cache = instance_variable_get(variable_name) || instance_variable_set(variable_name, {})
-      end
-      
-      def owner_tag_list_on(owner, context)
-        add_custom_context(context)
-
-        cache = cached_owned_tag_list_on(context)
-        cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
-        
-        cache[owner] ||= TagList.new(*owner_tags_on(owner, context).map(&:name))
-      end
-      
-      def set_owner_tag_list_on(owner, context, new_list)
-        add_custom_context(context)
-        
-        cache = cached_owned_tag_list_on(context)
-        cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
-
-        cache[owner] = TagList.from(new_list)
-      end
-      
-      def reload
-        self.class.tag_types.each do |context|
-          instance_variable_set("@owned_#{context}_list", nil)
-        end
-      
-        super
-      end
-    
-      def save_owned_tags
-        transaction do
-          tagging_contexts.each do |context|
-            cached_owned_tag_list_on(context).each do |owner, tag_list|
-              # Find existing tags or create non-existing tags:
-              tag_list = Tag.find_or_create_all_with_like_by_name(tag_list.uniq)            
- 
-              owned_tags = owner_tags_on(owner, context)              
-              old_tags   = owned_tags - tag_list
-              new_tags   = tag_list   - owned_tags
-            
-              # Find all taggings that belong to the taggable (self), are owned by the owner, 
-              # have the correct context, and are removed from the list.
-              old_taggings = Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
-                                           :tagger_type => owner.class.to_s, :tagger_id => owner.id,
-                                           :tag_id => old_tags, :context => context).all
-            
-              if old_taggings.present?
-                # Destroy old taggings:
-                Tagging.destroy_all(:id => old_taggings.map(&:id))
-              end
-
-              # Create new taggings:
-              new_tags.each do |tag|
-                Tagging.create!(:tag_id => tag.id, :context => context.to_s, :tagger => owner, :taggable => self)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/acts_as_taggable_on/acts_as_taggable_on/related.rb

@@ -1,64 +0,0 @@
-module ActsAsTaggableOn::Taggable
-  module Related
-    def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Related::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
-    end
-    
-    module ClassMethods
-      def initialize_acts_as_taggable_on_related
-        tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
-            def find_related_#{tag_type}(options = {})
-              related_tags_for('#{tag_type}', self.class, options)
-            end
-            alias_method :find_related_on_#{tag_type}, :find_related_#{tag_type}
-
-            def find_related_#{tag_type}_for(klass, options = {})
-              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
-          )
-        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
-        
-        klass.scoped({ :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 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
-
-        klass.scoped({ :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 (?)", tags_to_find],
-                 :group      => grouped_column_names_for(klass),
-                 :order      => "count DESC" }.update(options))
-      end
-    end
-  end
-end

data/lib/acts_as_taggable_on/acts_as_taggable_on.rb

@@ -1,41 +0,0 @@
-module ActsAsTaggableOn
-  module Taggable
-    def taggable?
-      false
-    end
-
-    def acts_as_taggable
-      acts_as_taggable_on :tags
-    end
-
-    def acts_as_taggable_on(*tag_types)
-      tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
-
-      if taggable?
-        write_inheritable_attribute(:tag_types, (self.tag_types + tag_types).uniq)
-      else
-        if ::ActiveRecord::VERSION::MAJOR < 3
-          include ActsAsTaggableOn::ActiveRecord::Backports
-        end
-
-        write_inheritable_attribute(:tag_types, tag_types)
-        class_inheritable_reader(:tag_types)
-        
-        class_eval do
-          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag
-          has_many :base_tags, :class_name => "Tag", :through => :taggings, :source => :tag
-
-          def self.taggable?
-            true
-          end
-        
-          include ActsAsTaggableOn::Taggable::Core
-          include ActsAsTaggableOn::Taggable::Collection
-          include ActsAsTaggableOn::Taggable::Cache
-          include ActsAsTaggableOn::Taggable::Ownership
-          include ActsAsTaggableOn::Taggable::Related
-        end
-      end
-    end
-  end
-end

data/lib/acts_as_taggable_on/acts_as_tagger.rb

@@ -1,47 +0,0 @@
-module ActsAsTaggableOn
-  module Tagger
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def acts_as_tagger(opts={})
-        has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy,
-                                             :include => :tag, :class_name => "Tagging")
-        has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true
-
-        include ActsAsTaggableOn::Tagger::InstanceMethods
-        extend ActsAsTaggableOn::Tagger::SingletonMethods
-      end
-
-      def is_tagger?
-        false
-      end
-    end
-
-    module InstanceMethods
-      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

@@ -1,6 +0,0 @@
-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'

data/lib/acts_as_taggable_on/compatibility/active_record_backports.rb

@@ -1,17 +0,0 @@
-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 } }   
-        end
-      end
-    end
-  end
-end

data/lib/generators/acts_as_taggable_on/migration/migration_generator.rb

@@ -1,31 +0,0 @@
-require 'rails/generators/migration'
-
-module ActsAsTaggableOn
-  class MigrationGenerator < Rails::Generators::Base
-    include Rails::Generators::Migration
-
-    desc "Generates migration for Tag and Tagging models"
-
-    def self.orm
-      Rails::Generators.options[:rails][:orm]
-    end
-
-    def self.source_root
-      File.join(File.dirname(__FILE__), 'templates', orm)
-    end
-
-    def self.orm_has_migration?
-      [:active_record].include? orm
-    end
-
-    def self.next_migration_number(path)
-      Time.now.utc.strftime("%Y%m%d%H%M%S")
-    end
-
-    def create_migration_file
-      if self.class.orm_has_migration?
-        migration_template 'migration.rb', 'db/migrate/acts_as_taggable_on_migration'
-      end
-    end
-  end
-end

data/rails/init.rb

@@ -1 +0,0 @@
-require 'acts-as-taggable-on'

data/spec/bm.rb

@@ -1,52 +0,0 @@
-require 'active_record'
-require 'action_view'
-require File.expand_path('../../lib/acts-as-taggable-on', __FILE__)
-
-if defined?(ActiveRecord::Acts::TaggableOn)
-  ActiveRecord::Base.send :include, ActiveRecord::Acts::TaggableOn
-  ActiveRecord::Base.send :include, ActiveRecord::Acts::Tagger
-  ActionView::Base.send :include, TagsHelper if defined?(ActionView::Base)
-end
-
-TEST_DATABASE_FILE = File.join(File.dirname(__FILE__), '..', 'test.sqlite3')
-File.unlink(TEST_DATABASE_FILE) if File.exist?(TEST_DATABASE_FILE)
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => TEST_DATABASE_FILE
-
-ActiveRecord::Base.silence do
-  ActiveRecord::Migration.verbose = false
-  ActiveRecord::Schema.define :version => 0 do
-    create_table "taggings", :force => true do |t|
-      t.integer  "tag_id",        :limit => 11
-      t.integer  "taggable_id",   :limit => 11
-      t.string   "taggable_type"
-      t.string   "context"
-      t.datetime "created_at"
-      t.integer  "tagger_id",     :limit => 11
-      t.string   "tagger_type"
-    end
-
-    add_index "taggings", ["tag_id"], :name => "index_taggings_on_tag_id"
-    add_index "taggings", ["taggable_id", "taggable_type", "context"], :name => "index_taggings_on_taggable_id_and_taggable_type_and_context"
-
-    create_table "tags", :force => true do |t|
-      t.string "name"
-    end
-
-    create_table :taggable_models, :force => true do |t|
-      t.column :name, :string
-      t.column :type, :string
-      t.column :cached_tag_list, :string
-    end
-  end
-
-  class TaggableModel < ActiveRecord::Base
-    acts_as_taggable
-    acts_as_taggable_on :languages
-    acts_as_taggable_on :skills
-    acts_as_taggable_on :needs, :offerings
-  end
-end
-
-puts Benchmark.measure {
-  1000.times { TaggableModel.create :tag_list => "awesome, epic, neat" }
-}

data/spec/models.rb

@@ -1,36 +0,0 @@
-class TaggableModel < ActiveRecord::Base
-  acts_as_taggable
-  acts_as_taggable_on :languages
-  acts_as_taggable_on :skills
-  acts_as_taggable_on :needs, :offerings
-end
-
-class CachedModel < ActiveRecord::Base
-  acts_as_taggable
-end
-
-class OtherTaggableModel < ActiveRecord::Base
-  acts_as_taggable_on :tags, :languages
-  acts_as_taggable_on :needs, :offerings
-end
-
-class InheritingTaggableModel < TaggableModel
-end
-
-class AlteredInheritingTaggableModel < TaggableModel
-  acts_as_taggable_on :parts
-end
-
-class TaggableUser < ActiveRecord::Base
-  acts_as_tagger
-end
-
-class UntaggableModel < ActiveRecord::Base
-end
-
-# if ActiveRecord::VERSION::MAJOR < 3
-#   [TaggableModel, CachedModel, OtherTaggableModel, InheritingTaggableModel,
-#    AlteredInheritingTaggableModel, TaggableUser, UntaggableModel].each do |klass|
-#     klass.send(:include, ActsAsTaggableOn::ActiveRecord::Backports)
-#   end
-# end

data/spec/schema.rb

@@ -1,42 +0,0 @@
-ActiveRecord::Schema.define :version => 0 do
-  create_table "taggings", :force => true do |t|
-    t.integer  "tag_id",        :limit => 11
-    t.integer  "taggable_id",   :limit => 11
-    t.string   "taggable_type"
-    t.string   "context"
-    t.datetime "created_at"
-    t.integer  "tagger_id",     :limit => 11
-    t.string   "tagger_type"
-  end
-
-  add_index "taggings", ["tag_id"], :name => "index_taggings_on_tag_id"
-  add_index "taggings", ["taggable_id", "taggable_type", "context"], :name => "index_taggings_on_taggable_id_and_taggable_type_and_context"
-
-  create_table "tags", :force => true do |t|
-    t.string "name"
-  end
-  
-  create_table :taggable_models, :force => true do |t|
-    t.column :name, :string
-    t.column :type, :string
-  end
-  
-  create_table :cached_models, :force => true do |t|
-    t.column :name, :string
-    t.column :type, :string
-    t.column :cached_tag_list, :string
-  end
-  
-  create_table :taggable_users, :force => true do |t|
-    t.column :name, :string
-  end
-  
-  create_table :other_taggable_models, :force => true do |t|
-    t.column :name, :string
-    t.column :type, :string
-  end
-  
-  create_table :untaggable_models, :force => true do |t|
-    t.column :name, :string
-  end
-end