taxonomy 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 Seth Faxon
+
+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,28 @@
+= Taxonomy
+
+this gem is an active record plugin. think of it as a merger of http://rubygems.org/gems/acts-as-taggable-on and http://rubygems.org/gems/awesome_nested_set because, well it is.  With some glue code and updates to the models.
+
+
+== Setup Rails 3.x
+
+Add to Gemfile:
+
+  gem 'taxonomy'
+
+Run migration:
+
+  rails generate taxonomy:migration
+  rake db:migrate
+
+
+== Usage
+
+to setup plain tags and a treed set of categories
+
+  has_taxonomy_on :tags, {:treed => [:categories]}
+
+
+  Tag.roots.where(:context => "category")
+
+
+  Tag.find_context_with_slug!("category", params[:slug])

data/Rakefile

@@ -0,0 +1,31 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rake/dsl_definition'
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Taxonomy'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+# load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }
+
+task :default => :spec

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

@@ -0,0 +1,39 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Taxonomy
+  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.to_s unless orm.class.eql?(String)) )
+    end
+
+    def self.orm_has_migration?
+      [:active_record].include? orm
+    end
+
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        migration_number += 1
+        migration_number.to_s
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+
+    def create_migration_file
+      if self.class.orm_has_migration?
+        migration_template 'migration.rb', 'db/migrate/taxonomy_migration'
+      end
+    end
+  end
+end
+

data/lib/generators/taxonomy/migration/templates/active_record/migration.rb

@@ -0,0 +1,36 @@
+class TaxonomyMigration < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.integer :parent_id
+      t.integer :lft
+      t.integer :rgt
+      t.string  :name
+      t.string  :context
+      t.string  :slug
+    end
+
+    create_table :taggings do |t|
+      t.references :tag
+
+      # You should make sure that the column created is
+      # long enough to store the required class names.
+      t.references :taggable, :polymorphic => true
+      t.references :tagger, :polymorphic => true
+
+      t.datetime :created_at
+    end
+    
+    add_index :tags, [:parent_id]
+    add_index :tags, [:lft, :rgt]
+    add_index :tags, :context
+    add_index :tags, :slug
+
+    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/tasks/taxonomy_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :taxonomy do
+#   # Task goes here
+# end

data/lib/taxonomy.rb

@@ -0,0 +1,25 @@
+module Taxonomy
+  mattr_accessor :nested_set_options
+  @@nested_set_options = { :parent_column => 'parent_id',
+                           :left_column => 'lft',
+                           :right_column => 'rgt',
+                           :dependent => :destroy
+                         }
+
+  def self.setup
+    yield self
+    @@nested_set_options.symbolize_keys!
+  end
+end
+
+require 'taxonomy/group_helper'
+require 'taxonomy/has_taxonomy'
+require 'taxonomy/has_tagger'
+require 'taxonomy/tag'
+require 'taxonomy/tag_list'
+require 'taxonomy/tags_helper'
+require 'taxonomy/tagging'
+
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Taxonomy
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Tagger
+ActionView::Base.send :include, TagsHelper if defined?(ActionView::Base)

data/lib/taxonomy/group_helper.rb

@@ -0,0 +1,12 @@
+module ActiveRecord
+  module Acts
+    module Taxonomy
+      module GroupHelper
+        # 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(", ")
+        end
+      end
+    end
+  end
+end

data/lib/taxonomy/has_tagger.rb

@@ -0,0 +1,52 @@
+module ActiveRecord
+  module Acts
+    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 ActiveRecord::Acts::Tagger::InstanceMethods
+          extend ActiveRecord::Acts::Tagger::SingletonMethods       
+        end
+        
+        def is_tagger?
+          false
+        end
+      end
+      
+      module InstanceMethods
+        def self.included(base)
+        end
+        
+        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_tag_list_on(opts[:on].to_s, opts[:with], self)
+          taggable.save
+        end
+        
+        def is_tagger?
+          self.class.is_tagger?
+        end
+      end
+      
+      module SingletonMethods
+        def is_tagger?
+          true
+        end
+      end
+      
+    end
+  end
+end

data/lib/taxonomy/has_taxonomy.rb

@@ -0,0 +1,502 @@
+module ActiveRecord
+  module Acts
+    module Taxonomy
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def taggable?
+          false
+        end
+
+        def acts_as_taggable
+          has_taxonomy_on :tags
+        end
+
+        def has_taxonomy_on(*args)
+          treed_args = []
+          args.flatten! if args
+          args.compact! if args 
+          # pull out treed args
+          args.each do |tag_type|
+            if tag_type.is_a?(Hash)
+              treed_tags = tag_type.values.flatten
+              treed_tags.compact!
+              
+              treed_tags.each do |tree|
+                treed_args << tree
+              end
+              args.delete(tag_type)
+            end
+          end
+          
+          if !(args & treed_args).empty?
+            raise "duplicate taxonomy keys"
+          end
+          args.concat(treed_args)
+          args.flatten!
+          args.map!{|x| x.to_s} # convert to strings
+          treed_args.map!{|x| x.to_s}
+          args.each do |tag_type|
+            # 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
+            class_eval do
+              has_many "#{tag_type.singularize}_taggings".to_sym, :as => :taggable, :dependent => :destroy,
+                :include => :tag, :conditions => ['tags.context = ?',tag_type.singularize], :class_name => "Tagging"
+              has_many "#{tag_type}".to_sym, :through => "#{tag_type.singularize}_taggings".to_sym, :source => :tag
+            end
+
+            class_eval <<-RUBY
+              def self.taggable?
+                true
+              end
+              
+              def self.#{tag_type}_treed?
+                treed_list_on?("#{tag_type}")
+              end
+
+              def self.caching_#{tag_type.singularize}_list?
+                caching_tag_list_on?("#{tag_type}")
+              end
+
+              def self.#{tag_type.singularize}_counts(options={})
+                tag_counts_on('#{tag_type}',options)
+              end
+
+              def #{tag_type.singularize}_list
+                tag_list_on('#{tag_type}')
+              end
+
+              def #{tag_type.singularize}_list=(new_tags)
+                set_tag_list_on('#{tag_type}',new_tags)
+              end
+
+              def #{tag_type.singularize}_counts(options = {})
+                tag_counts_on('#{tag_type}',options)
+              end
+
+              def #{tag_type}_from(owner)
+                tag_list_on('#{tag_type}', owner)
+              end
+
+              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
+
+              def top_#{tag_type}(limit = 10)
+                tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
+              end
+
+              def self.top_#{tag_type}(limit = 10)
+                tag_counts_on('#{tag_type}', :order => 'count desc', :limit => limit.to_i)
+              end
+            RUBY
+            
+          end
+          if respond_to?(:tag_types)
+            write_inheritable_attribute( :tag_types, (tag_types + args).uniq )
+            write_inheritable_attribute( :treed_tag_types, treed_args)
+          else
+            class_eval do
+              write_inheritable_attribute(:tag_types, args.uniq)
+              class_inheritable_reader :tag_types
+              
+              write_inheritable_attribute( :treed_tag_types, treed_args.uniq)
+              class_inheritable_reader :treed_tag_types
+
+              has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag
+              has_many :base_tags, :class_name => "Tag", :through => :taggings, :source => :tag
+
+              attr_writer :custom_contexts
+
+              before_save :save_cached_tag_list
+              after_save :save_tags
+
+              if respond_to?(:scope)
+                scope :tagged_with, lambda{ |*args|
+                  find_options_for_find_tagged_with(*args)
+                }
+              end
+              
+            end
+
+            include ActiveRecord::Acts::Taxonomy::InstanceMethods
+            extend ActiveRecord::Acts::Taxonomy::SingletonMethods
+            alias_method_chain :reload, :tag_list
+          end
+        end
+      end
+
+      module SingletonMethods
+        include ActiveRecord::Acts::Taxonomy::GroupHelper
+        # 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
+        #   :on - scopes the find to a context
+        def find_tagged_with(context, name, *args)
+          find_opts = {:on => context}
+          case args #fixme: args will probably always be an array
+          when Array
+            if args.first.is_a?(Hash)
+              find_opts.merge!(args.first)
+            end
+          end
+          options = find_options_for_find_tagged_with(name, find_opts)
+          options.blank? ? [] : find(:all,options)
+        end
+
+        def caching_tag_list_on?(context)
+          column_names.include?("cached_#{context.to_s.singularize}_list")
+        end
+        
+        def treed_list_on?(context)
+          treed_tag_types.include?(context)
+        end
+
+        def tag_counts_on(context, options = {})
+          Tag.all(find_options_for_tag_counts(options.merge({:on => context.to_s.singularize})))
+        end
+
+        def all_tag_counts(options = {})
+          Tag.all(find_options_for_tag_counts(options))
+        end
+
+        def find_options_for_find_tagged_with(tags, options = {})
+          tag_list = TagList.from(tags)
+
+          return {} if tag_list.empty?
+
+          joins = []
+          conditions = []
+
+          context = options.delete(:on)
+          context = context.to_s.singularize
+
+          if options.delete(:exclude)
+            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_any(context, tag_list)
+            return { :conditions => "1 = 0" } unless tags.length == tag_list.length
+                      
+            tags.each do |tag|
+              safe_tag = tag.name.gsub(/[^a-zA-Z0-9]/, '')
+              prefix   = "#{safe_tag}_#{rand(1024)}"
+
+              taggings_alias = "#{table_name}_taggings_#{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}.tag_id = #{tag.id}"
+              # tagging_join << " AND " + sanitize_sql(["tags.context = ?", context.to_s]) if context
+
+              joins << tagging_join
+            end
+          end
+
+          taggings_alias, tags_alias = "#{table_name}_taggings_group", "#{table_name}_tags_group"
+
+          if options.delete(:match_all)
+            joins << "LEFT OUTER 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)}"
+
+            group = "#{grouped_column_names_for(self)} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
+          end
+
+          { :joins      => joins.join(" "),
+            :group      => group,
+            :conditions => conditions.join(" AND "),
+            :readonly   => false }.update(options)
+        end
+
+        # Calculate the tag counts for all tags.
+        #
+        # 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
+        #  :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'
+        #  :at_least - Exclude tags with a frequency less than the given value
+        #  :at_most - Exclude tags with a frequency greater than the given value
+        #  :on - Scope the find to only include a certain context
+        def find_options_for_tag_counts(options = {})
+          options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
+
+          # scope = scope(:find)
+
+          start_at = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+          end_at = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
+
+          taggable_type = sanitize_sql(["#{Tagging.table_name}.taggable_type = ?", base_class.name])
+          taggable_id = sanitize_sql(["#{Tagging.table_name}.taggable_id = ?", options.delete(:id)]) if options[:id]
+          options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
+
+          conditions = [
+            taggable_type,
+            taggable_id,
+            options[:conditions],
+            start_at,
+            end_at
+          ]
+
+          conditions = conditions.compact.join(' AND ')
+          # conditions = merge_conditions(conditions, scope[:conditions]) if scope
+
+          joins = ["LEFT OUTER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"]
+          joins << sanitize_sql(["AND #{Tag.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 descends_from_active_record?
+            # Current model is STI descendant, so add type checking to the join condition
+            joins << " AND #{table_name}.#{inheritance_column} = '#{name}'"
+          end
+
+          # 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]
+          having    = [at_least, at_most].compact.join(' AND ')
+          if joins.include?(".context") # if :on is passed
+            group_by  = "#{grouped_column_names_for(Tag)} HAVING COUNT(*) > 0"
+          else
+            group_by  = "tags.name HAVING COUNT(*) > 0"
+          end
+          group_by << " AND #{having}" unless having.blank?
+
+          { :select     => "#{Tag.table_name}.*, COUNT(*) AS count",
+            :joins      => joins.join(" "),
+            :conditions => conditions,
+            :group      => group_by,
+            :limit      => options[:limit],
+            :order      => options[:order]
+          }
+        end
+
+        def is_taggable?
+          true
+        end
+      end
+
+      module InstanceMethods
+        include ActiveRecord::Acts::Taxonomy::GroupHelper
+
+        def custom_contexts
+          @custom_contexts ||= []
+        end
+
+        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) || self.class.tag_types.map(&:to_s).include?(value.to_s)
+        end
+
+        def tag_list_on(context, owner = nil)
+          context = context.to_s.singularize
+          add_custom_context(context)
+          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?
+            cache[owner] = TagList.from(cached_tag_list_on(context))
+          else
+            cache[owner] = TagList.new(*tags_on(context, owner).map(&:name))
+          end
+        end
+        
+        def all_tags_list_on(context)
+          context = context.to_s.singularize
+          variable_name = "@all_#{context}_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)
+          context = context.to_s.singularize
+          opts = {:conditions => ["#{Tag.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)
+          context = context.to_s.singularize
+          if owner
+            base_tags.where("#{Tag.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
+            base_tags.where("#{Tag.table_name}.context = ? AND #{Tagging.table_name}.tagger_id IS NULL", context.to_s)
+          end
+        end
+
+        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)
+          context = context.to_s.singularize
+          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.to_s.singularize, options.merge(:id => id))
+        end
+
+        def related_tags_for(context, klass, options = {})
+          search_conditions = related_search_options(context.to_s.singularize, klass, options)
+
+          klass.find(:all, search_conditions)
+        end
+
+        def related_search_options(context, klass, options = {})
+          tags_to_find = tags_on(context.to_s.singularize).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 (?)", tags_to_find],
+            :group      => grouped_column_names_for(klass),
+            :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 = {})
+          search_context = search_context.to_s.singularize
+          result_context = result_context.to_s.singularize
+          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 #{Tag.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"] = tag_list_cache_on(tag_type.singularize).to_a.flatten.compact.join(', ')
+            end
+          end
+        end
+
+        def save_tags
+          contexts = custom_contexts + self.class.tag_types.map(&:to_s)
+          transaction do
+            contexts.each do |context|
+              context = context.to_s.singularize
+              
+              cache = tag_list_cache_on(context)
+              
+              cache.each do |owner, list|
+                new_tags = Tag.find_or_create_all_with_like_by_name(context, list.uniq)
+                taggings = Tagging.joins(:tag).where(:taggable_id => self.id, :taggable_type => self.class.base_class.to_s, "tags.context" => context ).all
+
+                # Destroy old taggings:
+                if owner
+                  old_tags = tags_on(context, owner) - new_tags
+                  
+                  old_taggings = Tagging.joins(:tag).where(:taggable_id => self.id, 
+                                                           :taggable_type => self.class.base_class.to_s, 
+                                                           :tag_id => old_tags, 
+                                                           :tagger_id => owner.id, 
+                                                           :tagger_type => owner.class.to_s, 
+                                                           "tags.context" => context)
+
+                  Tagging.destroy_all :id => old_taggings.map(&:id)
+                else
+                  old_tags = tags_on(context) - new_tags
+                  base_tags.delete(*old_tags)                
+                end
+ 
+                new_tags.reject! { |tag| taggings.any? { |tagging|
+                    tagging.tag_id      == tag.id &&
+                    tagging.tagger_id   == (owner ? owner.id : nil) &&
+                    tagging.tagger_type == (owner ? owner.class.to_s : nil) &&
+                    tagging.tag.context == context
+                  }
+                }
+                
+                # create new taggings:
+                new_tags.each do |tag|
+                  Tagging.create!(:tag_id => tag.id, :tagger => owner, :taggable => self)
+                end
+              end
+            end
+          end          
+
+          true
+        end
+
+        def reload_with_tag_list(*args)
+          self.class.tag_types.each do |tag_type|
+            instance_variable_set("@#{tag_type.to_s.singularize}_list", nil)
+          end
+
+          reload_without_tag_list(*args)
+        end
+      end
+    end
+  end
+end