tagtools 0.0.1

data/CHANGELOG

@@ -0,0 +1,2 @@
+== TagTools 0.0.1
+ * folksonomy!

data/README

@@ -0,0 +1,40 @@
+TagTools is a simple ruby library for managing folksonomy tags within a Rails
+applications.  It supports tagging of any number of database tables (i.e.,
+you can tag different types of data using the same mechanism).  It can merge
+tags, delete tags, and rename tags.  TagTools uses a fully normalized tag
+schema.
+
+== Example
+ class User < ActiveRecord::Base
+ end
+ class Tag < ActiveRecord::Base
+   def inspect
+     return "tag:" + self.name.inspect
+   end
+   def to_s
+     return self.name
+   end
+ end
+ class Bookmark < ActiveRecord::Base
+   acts_as_taggable :scope => :user
+ end
+ 
+ current_user = User.new
+ current_user.name = "Joe Schmoe"
+ current_user.save
+ slashdot_bookmark = Bookmark.new
+ slashdot_bookmark.url = "http://slashdot.org"
+ slashdot_bookmark.save
+ slashdot_bookmark.user_tags(current_user.id).concat( "geeky", "news", "technology" )
+ slashdot_bookmark.tags
+ => [ tag:"geeky", tag:"news", tag:"technology" ]
+ slashdot_bookmark.user_tags(current_user).delete( "news" )
+ slashdot_bookmark.tags
+ => [ tag:"geeky", tag:"technology" ]
+ slashdot_bookmark.user_tags(current_user).concat( "technology", "linux" )
+ slashdot_bookmark.tags
+ => [ tag:"geeky", tag:"technology", tag:"linux" ]
+ Bookmark.tag_query( :user_id => current_user, :with_any_tags => ["linux"] )
+ => []
+ Bookmark.tag_query( :with_any_tags => ["linux"] )
+ => [ #<Bookmark:0x77dc54 @attributes={"url"=>"http://slashdot.org"}> ]

data/install.rb

@@ -0,0 +1,30 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+# this was adapted from rdoc's install.rb by ways of Log4r
+
+$sitedir = CONFIG["sitelibdir"]
+unless $sitedir
+  version = CONFIG["MAJOR"] + "." + CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/ }
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+# the acual gruntwork
+Dir.chdir("lib")
+
+Find.find("tagtools", "tagtools.rb") { |f|
+  if f[-3..-1] == ".rb"
+    File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
+  else
+    File::makedirs(File.join($sitedir, *f.split(/\//)))
+  end
+}

data/lib/tagtools.rb

@@ -0,0 +1,1026 @@
+#--
+# Copyright (c) 2005 Robert Aman
+#
+# 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.
+#++
+
+TAG_TOOLS_VERSION = "0.0.1"
+
+$:.unshift(File.dirname(__FILE__))
+$:.unshift(File.dirname(__FILE__) + "/../../activerecord/lib")
+
+require 'rubygems'
+require 'active_record'
+
+module ActiveRecord #:nodoc:
+  module Associations #:nodoc:
+    class GlobalTagsAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, tag_class, item_class, options)
+        @owner = owner
+
+        @tag_class = tag_class
+        @tag_class_name = tag_class.name
+        @tag_foreign_key = options[:tag_foreign_key] ||
+          Inflector.underscore(
+            Inflector.demodulize(@tag_class.name)) + "_id"
+        @item_class = item_class
+        @item_class_name = item_class.name
+        @item_foreign_key = options[:item_foreign_key] ||
+          Inflector.underscore(
+            Inflector.demodulize(@item_class.name)) + "_id"
+
+        @join_table = options[:join_table]
+        @options = options
+
+        # For the sake of the classes we inheritted from,
+        # since we're not calling super
+        @association_class = @tag_class
+        @association_name = Inflector.pluralize(
+          Inflector.underscore(Inflector.demodulize(@tag_class.name)))
+        @association_class_primary_key_name = @item_foreign_key
+
+        reset                
+        construct_sql
+      end
+
+      def build(attributes = {})
+        load_target
+        record = @item_class.new(attributes)
+        record[@item_foreign_key] = @owner.id unless @owner.new_record?
+        @target << record
+        return record
+      end
+
+      # Removes all records from this association.
+      # Returns +self+ so method calls may be chained.
+      def clear
+
+        # forces load_target if hasn't happened already
+        return self if size == 0
+
+        @owner.connection.execute("DELETE FROM #{@join_table} " +
+          "WHERE #{@join_table}.#{@item_foreign_key} = " +
+          "  '#{@owner.id}'")
+
+        @target = []
+        self
+      end
+
+      def find_first
+        load_target.first
+      end
+
+      def find(*args)
+        # Return an Array if multiple ids are given.
+        expects_array = args.first.kind_of?(Array)
+
+        ids = args.flatten.compact.uniq
+
+        # If no block is given, raise RecordNotFound.
+        if ids.empty?
+          raise RecordNotFound, "Couldn't find #{@tag_class.name} without an ID"
+        else
+          if ids.size == 1
+            id = ids.first
+            record = load_target.detect { |record| id == record.id }
+            expects_array? ? [record] : record
+          else
+            load_target.select { |record| ids.include?(record.id) }
+          end
+        end
+      end
+
+      def push_with_attributes(record, join_attributes = {})
+        unless record.kind_of? @tag_class
+          record = record.to_s.create_tag
+        end
+        join_attributes.each { |key, value| record[key.to_s] = value }
+        callback(:before_add, record)
+        insert_record(record, join_attributes) unless @owner.new_record?
+        @target << record
+        callback(:after_add, record)
+        @target.sort!
+        return self
+      end      
+
+      alias :concat_with_attributes :push_with_attributes
+
+      def size
+        count_records
+      end
+
+      def <<(*records)
+        result = true
+        load_target
+        @owner.transaction do
+          flatten_deeper(records).each do |record|
+            record = create_tag(record)
+            callback(:before_add, record)
+            result &&= insert_record(record) unless @owner.new_record?
+            @target << record
+            callback(:after_add, record)
+          end
+        end
+        @target.sort!
+        result and self
+      end
+
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      # Remove +records+ from this association.  Does not destroy +records+.
+      def delete(*records)
+        records = flatten_deeper(records)
+        for index in 0..records.size
+          records[index] = create_tag(records[index])
+        end
+        records.reject! do |record|
+          @target.delete(record) if record.new_record?
+        end
+        return if records.empty?
+
+        @owner.transaction do
+          records.each { |record| callback(:before_remove, record) }
+          delete_records(records)
+          records.each do |record|
+            @target.delete(record)
+            callback(:after_remove, record)
+          end
+        end
+      end
+
+    protected
+      def create_tag(raw_tag)
+        if raw_tag.kind_of? @tag_class
+          return raw_tag
+        end
+        tag_object = @tag_class.find_by_name(raw_tag.to_s)
+        if tag_object.nil?
+          tag_object = @tag_class.new
+          tag_object.name = raw_tag.to_s
+          tag_object.save
+        end
+        return tag_object
+      end
+
+      def find_target(sql = @finder_sql)
+        records = @tag_class.find_by_sql(sql)
+        uniq(records)
+      end
+
+      def count_records
+        load_target.size
+      end
+
+      def insert_record(record, join_attributes = {})
+        record = create_tag(record)
+        if record.new_record?
+          return false unless record.save
+        end
+
+        columns = @owner.connection.columns(@join_table, "#{@join_table} Columns")
+
+        attributes = columns.inject({}) do |attributes, column|
+          case column.name
+            when @item_foreign_key
+              attributes[column.name] = @owner.quoted_id
+            when @tag_foreign_key
+              attributes[column.name] = record.quoted_id
+            else
+              value = record[column.name]
+              attributes[column.name] = value unless value.nil?
+          end
+          attributes
+        end
+
+        columns_list = @owner.send(:quoted_column_names,
+          attributes).join(', ')
+        values_list = attributes.values.collect { |value|
+          @owner.send(:quote, value)
+        }.join(', ')
+
+        sql =
+          "INSERT INTO #{@join_table} (#{columns_list}) " +
+          "VALUES (#{values_list})"
+
+        @owner.connection.execute(sql)
+
+        return true
+      end
+
+      def delete_records(records)
+        ids = quoted_record_ids(records)
+        sql = "DELETE FROM #{@join_table} " +
+          "WHERE #{@item_foreign_key} = " +
+          "  #{@owner.quoted_id} " +
+          "AND #{@tag_foreign_key} IN (#{ids})"
+        @owner.connection.execute(sql)
+      end
+
+      def construct_sql
+        @finder_sql = 
+          "SELECT t.*, j.* FROM #{@join_table} j, " +
+          "  #{@tag_class.table_name} t " +
+          "WHERE t.#{@tag_class.primary_key} = " +
+          "  j.#{@tag_foreign_key} " +
+          "AND j.#{@item_foreign_key} = " +
+          "  #{@owner.quoted_id} " +
+          "ORDER BY t.name"
+      end
+    end
+
+    class UserTagsAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, user_id, tag_class, user_class, item_class,
+          options)
+        @owner = owner
+        @user_id = user_id
+        
+        @tag_class = tag_class
+        @tag_class_name = tag_class.name
+        @tag_foreign_key = options[:tag_foreign_key] ||
+          Inflector.underscore(
+            Inflector.demodulize(@tag_class.name)) + "_id"
+        @user_class = user_class
+        @user_class_name = user_class.name
+        @user_foreign_key = options[:user_foreign_key] ||
+          Inflector.underscore(
+            Inflector.demodulize(@user_class.name)) + "_id"
+        @item_class = item_class
+        @item_class_name = item_class.name
+        @item_foreign_key = options[:item_foreign_key] ||
+          Inflector.underscore(
+            Inflector.demodulize(@item_class.name)) + "_id"
+        
+        @join_table = options[:join_table]
+        @options = options
+        
+        # For the sake of the classes we inheritted from,
+        # since we're not calling super
+        @association_class = @tag_class
+        @association_name = Inflector.pluralize(
+          Inflector.underscore(Inflector.demodulize(@tag_class.name)))
+        @association_class_primary_key_name = @item_foreign_key
+
+        reset                
+        construct_sql
+      end
+
+      def build(attributes = {})
+        if @user_id.nil?
+          raise "Can only build object if a tagging user has been specified."
+        else
+          load_target
+          record = @item_class.new(attributes)
+          record[@item_foreign_key] = @owner.id unless @owner.new_record?
+          @target << record
+          return record
+        end
+      end
+
+      # Removes all records from this association.
+      # Returns +self+ so method calls may be chained.
+      def clear
+        
+        # forces load_target if hasn't happened already
+        return self if size == 0
+        
+        if @user_id.nil?
+          raise "Tags on an item can only be cleared for one user at a time."
+        else
+          @owner.connection.execute("DELETE FROM #{@join_table} " +
+            "WHERE #{@join_table}.#{@item_foreign_key} = " +
+            "  '#{@owner.id}' AND #{@join_table}.#{@user_foreign_key} = " +
+            "  '#{@user_id}'")
+        end
+
+        @target = []
+        self
+      end
+
+      def find_first
+        load_target.first
+      end
+
+      def find(*args)
+        # Return an Array if multiple ids are given.
+        expects_array = args.first.kind_of?(Array)
+
+        ids = args.flatten.compact.uniq
+
+        # If no block is given, raise RecordNotFound.
+        if ids.empty?
+          raise RecordNotFound, "Couldn't find #{@tag_class.name} without an ID"
+        else
+          if ids.size == 1
+            id = ids.first
+            record = load_target.detect { |record| id == record.id }
+            expects_array? ? [record] : record
+          else
+            load_target.select { |record| ids.include?(record.id) }
+          end
+        end
+      end
+
+      def push_with_attributes(record, join_attributes = {})
+        if @user_id.nil?
+          raise "Cannot add record without a specific user id."
+        else
+          unless record.kind_of? @tag_class
+            record = record.to_s.create_tag
+          end
+          join_attributes.each { |key, value| record[key.to_s] = value }
+          callback(:before_add, record)
+          insert_record(record, join_attributes) unless @owner.new_record?
+          @target << record
+          @owner.instance_variable_set("@#{@options[:collection]}", nil)
+          callback(:after_add, record)
+          @target.sort!
+          return self
+        end
+      end      
+
+      alias :concat_with_attributes :push_with_attributes
+
+      def size
+        count_records
+      end
+
+      def <<(*records)
+        result = true
+        load_target
+        @owner.transaction do
+          flatten_deeper(records).each do |record|
+            record = create_tag(record)
+            callback(:before_add, record)
+            result &&= insert_record(record) unless @owner.new_record?
+            @target << record
+            @owner.instance_variable_set("@#{@options[:collection]}", nil)
+            callback(:after_add, record)
+          end
+        end
+        @target.sort!
+        result and self
+      end
+      
+      alias_method :push, :<<
+      alias_method :concat, :<<
+      
+      # Remove +records+ from this association.  Does not destroy +records+.
+      def delete(*records)
+        records = flatten_deeper(records)
+        for index in 0..records.size
+          records[index] = create_tag(records[index])
+        end
+        records.reject! do |record|
+          @target.delete(record) if record.new_record?
+        end
+        return if records.empty?
+
+        @owner.transaction do
+          records.each { |record| callback(:before_remove, record) }
+          delete_records(records)
+          records.each do |record|
+            @target.delete(record)
+            callback(:after_remove, record)
+          end
+        end
+      end
+      
+    protected
+      def create_tag(raw_tag)
+        if raw_tag.kind_of? @tag_class
+          return raw_tag
+        end
+        tag_object = @tag_class.find_by_name(raw_tag.to_s)
+        if tag_object.nil?
+          tag_object = @tag_class.new
+          tag_object.name = raw_tag.to_s
+          tag_object.save
+        end
+        return tag_object
+      end
+      
+      def find_target(sql = @finder_sql)
+        records = @tag_class.find_by_sql(sql)
+        uniq(records)
+      end
+
+      def count_records
+        load_target.size
+      end
+      
+      def insert_record(record, join_attributes = {})
+        if @user_id.nil?
+          raise "Cannot insert record if the user id is not set."
+        end
+        record = create_tag(record)
+
+        if record.new_record?
+          return false unless record.save
+        end
+        
+        columns = @owner.connection.columns(@join_table, "#{@join_table} Columns")
+
+        attributes = columns.inject({}) do |attributes, column|
+          case column.name
+            when @item_foreign_key
+              attributes[column.name] = @owner.quoted_id
+            when @tag_foreign_key
+              attributes[column.name] = record.quoted_id
+            when @user_foreign_key
+              attributes[column.name] = @user_id.to_s
+            else
+              value = record[column.name]
+              attributes[column.name] = value unless value.nil?
+          end
+          attributes
+        end
+
+        columns_list = @owner.send(:quoted_column_names,
+          attributes).join(', ')
+        values_list = attributes.values.collect { |value|
+          @owner.send(:quote, value)
+        }.join(', ')
+        
+        sql =
+          "INSERT INTO #{@join_table} (#{columns_list}) " +
+          "VALUES (#{values_list})"
+
+        @owner.connection.execute(sql)
+        
+        return true
+      end
+
+      def delete_records(records)
+        if @user_id.nil?
+          raise "Cannot delete records unless the user id is set."
+        end
+        ids = quoted_record_ids(records)
+        sql = "DELETE FROM #{@join_table} " +
+          "WHERE #{@item_foreign_key} = " +
+          "  #{@owner.quoted_id} " +
+          "AND #{@user_foreign_key} = '#{@user_id.to_s}'"
+          "AND #{@tag_foreign_key} IN (#{ids})"
+        @owner.connection.execute(sql)
+      end
+
+      def construct_sql
+        if @user_id.nil?
+          @finder_sql = 
+            "SELECT t.*, j.* FROM #{@join_table} j, " +
+            "  #{@tag_class.table_name} t " +
+            "WHERE t.#{@tag_class.primary_key} = " +
+            "  j.#{@tag_foreign_key} " +
+            "AND j.#{@item_foreign_key} = " +
+            "  #{@owner.quoted_id} " +
+            "ORDER BY t.name"
+        else
+          @finder_sql = 
+            "SELECT t.*, j.* FROM #{@join_table} j, " +
+            "  #{@tag_class.table_name} t " +
+            "WHERE t.#{@tag_class.primary_key} = " +
+            "  j.#{@tag_foreign_key} " +
+            "AND j.#{@item_foreign_key} = " +
+            "  #{@owner.quoted_id} " +
+            "AND j.#{@user_foreign_key} = " +
+            "  '#{@user_id}' " +
+            "ORDER BY t.name"
+        end
+      end
+    end
+  end
+  
+  module Acts #:nodoc:
+    module Taggable #:nodoc:
+      def self.append_features(base) #:nodoc:
+        super
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def acts_as_taggable(options = {})
+          validate_options([ :scope, :tag_class_name, :user_class_name,
+                             :item_foreign_key, :tag_foreign_key,
+                             :user_foreign_key, :collection, :user_collection,
+                             :conditions, :join_table, :before_add,
+                             :after_add, :before_remove, :after_remove ],
+                           options.keys)
+          options = { :scope => :global,
+                      :collection => :tags,
+                      :user_collection => :user_tags,
+                      :tag_class_name => 'Tag',
+                      :user_class_name => 'User' }.merge(options)
+                      
+          unless [:global, :user].include? options[:scope]
+            raise(ActiveRecord::ActiveRecordError,
+              ":scope must either be set to :global or :user.")
+          end
+
+          require_association(
+            Inflector.underscore(options[:tag_class_name]))
+
+          tag_class = eval(options[:tag_class_name])
+          tag_foreign_key = options[:tag_foreign_key] ||
+            Inflector.underscore(
+              Inflector.demodulize(tag_class.name)) + "_id"
+          item_class = self
+          item_foreign_key = options[:item_foreign_key] ||
+            Inflector.underscore(
+              Inflector.demodulize(item_class.name)) + "_id"
+
+          # Make sure we can sort tags
+          unless tag_class.method_defined?("<=>")
+            tag_class.module_eval do
+              define_method("<=>") do |raw_tag|
+                if raw_tag.kind_of? self.class
+                  return self.name <=> raw_tag.name
+                else
+                  return self.name <=> raw_tag.to_s
+                end
+              end
+            end
+          end
+
+          if options[:scope] == :user
+
+            require_association(
+              Inflector.underscore(options[:user_class_name]))
+
+            user_class = eval(options[:user_class_name])
+            user_foreign_key = options[:user_foreign_key] ||
+              Inflector.underscore(
+                Inflector.demodulize(user_class.name)) + "_id"
+
+            options[:join_table] ||=
+              join_table_name(
+                undecorated_table_name(tag_class.name),
+                undecorated_table_name(user_class.name),
+                undecorated_table_name(item_class.name))
+            
+            # Create the two collections
+            define_method(options[:collection]) do |*params|
+              force_reload = params.first unless params.empty?
+              association = instance_variable_get(
+                "@#{options[:collection]}")
+              unless association.respond_to?(:loaded?)
+                association =
+                  ActiveRecord::Associations::UserTagsAssociation.new(self,
+                    nil, tag_class, user_class, item_class, options)
+                instance_variable_set(
+                  "@#{options[:collection]}", association)
+              end
+              association.reload if force_reload
+              return association
+            end
+            
+            define_method(options[:user_collection]) do |user_id, *params|
+              unless user_id.kind_of? Fixnum
+                raise(ActiveRecord::ActiveRecordError,
+                  "Expected Fixnum, got #{user_id.class.name}")
+              end
+              force_reload = params.first unless params.empty?
+              association = instance_variable_get(
+                "@#{options[:user_collection]}_#{user_id}")
+              unless association.respond_to?(:loaded?)
+                association =
+                  ActiveRecord::Associations::UserTagsAssociation.new(self,
+                    user_id, tag_class, user_class, item_class, options)
+                instance_variable_set(
+                  "@#{options[:user_collection]}_#{user_id}", association)
+              end
+              association.reload if force_reload
+              return association
+            end
+            
+            singleton_class = class << self; self; end
+            singleton_class.module_eval do
+              define_method(:tag_query) do |*params|
+                query_options = params.first unless params.empty?
+                validate_options([:with_any_tags, :with_all_tags,
+                  :without_tags, :user_id], query_options.keys)
+                with_any_tags = query_options[:with_any_tags]
+                unless with_any_tags.nil?
+                  with_any_tags.collect! { |tag| tag.to_s }
+                  with_any_tags.uniq!
+                end
+                with_all_tags = query_options[:with_all_tags]
+                unless with_all_tags.nil?
+                  with_all_tags.collect! { |tag| tag.to_s }
+                  with_all_tags.uniq!
+                end
+                without_tags = query_options[:without_tags]
+                unless without_tags.nil?
+                  without_tags.collect! { |tag| tag.to_s }
+                  without_tags.uniq!
+                end
+                if without_tags != nil && with_any_tags == nil &&
+                    with_all_tags == nil
+                  raise(ActiveRecord::ActiveRecordError,
+                    "Cannot run this query, nothing to search for.")
+                end
+                tagging_user_id = query_options[:user_id]
+                results = []
+
+                group_by_string = item_class.table_name + "." +
+                  item_class.column_names.join(
+                    ", #{item_class.table_name}.")
+                tagging_user_id_string = ""
+                unless tagging_user_id.nil?
+                  tagging_user_id_string =
+                    "AND #{options[:join_table]}.#{user_foreign_key} = " +
+                    "#{tagging_user_id}"
+                end
+
+                with_all_tags_results = nil
+                if with_all_tags != nil && with_all_tags.size > 0
+                  with_all_tags_query_thread = Thread.new do
+                    tag_name_condition = "#{tag_class.table_name}.name = '" +
+                      with_all_tags.join(
+                        "\' OR #{tag_class.table_name}.name=\'") + "'"
+                    with_all_tags_sql = <<-SQL
+                      SELECT #{item_class.table_name}.*
+                      FROM #{options[:join_table]}, #{item_class.table_name},
+                        #{tag_class.table_name}
+                      WHERE #{options[:join_table]}.#{tag_foreign_key} =
+                        #{tag_class.table_name}.#{tag_class.primary_key}
+                      AND (#{tag_name_condition})
+                      AND #{item_class.table_name}.#{item_class.primary_key} =
+                        #{options[:join_table]}.#{item_foreign_key}
+                      #{tagging_user_id_string}
+                      GROUP BY #{group_by_string}
+                      HAVING COUNT(
+                        #{item_class.table_name}.#{item_class.primary_key}) =
+                        #{with_all_tags.size}
+                    SQL
+                    with_all_tags_results =
+                      item_class.find_by_sql(with_all_tags_sql)
+                  end
+                end
+
+                with_any_tags_results = nil
+                if with_any_tags != nil && with_any_tags.size > 0
+                  with_any_tags_query_thread = Thread.new do
+                    with_any_tags_sql = <<-SQL
+                      SELECT #{item_class.table_name}.*
+                      FROM #{options[:join_table]}, #{item_class.table_name},
+                        #{tag_class.table_name}
+                      WHERE #{tag_class.table_name}.name
+                      IN ('#{with_any_tags.join('\', \'')}')
+                      AND #{tag_class.table_name}.#{tag_class.primary_key} =
+                        #{options[:join_table]}.#{tag_foreign_key}
+                      AND #{item_class.table_name}.#{item_class.primary_key} =
+                        #{options[:join_table]}.#{item_foreign_key}
+                      #{tagging_user_id_string}
+                      GROUP BY #{group_by_string}
+                    SQL
+                    with_any_tags_results =
+                      item_class.find_by_sql(with_any_tags_sql)
+                  end
+                end
+
+                if with_all_tags != nil && with_all_tags.size > 0
+                  with_all_tags_query_thread.join
+                end
+                if with_any_tags != nil && with_any_tags.size > 0
+                  with_any_tags_query_thread.join
+                end
+                if with_any_tags_results != nil &&
+                    with_any_tags_results.size > 0 &&
+                    with_all_tags_results != nil &&
+                    with_all_tags_results.size > 0
+                  results = with_all_tags_results & with_any_tags_results
+                elsif with_any_tags_results != nil &&
+                    with_any_tags_results.size > 0
+                  results = with_any_tags_results
+                elsif with_all_tags_results != nil &&
+                    with_all_tags_results.size > 0
+                  results = with_all_tags_results
+                end
+                if without_tags != nil && without_tags.size > 0
+                  for result in results
+                    if ((result.tags.map { |tag| tag.name }) &
+                        without_tags).size > 0
+                      results.delete(result)
+                    end
+                  end
+                end
+                return results
+              end
+            end
+            
+            module_eval do
+              before_save <<-end_eval
+                @new_record_before_save = new_record?
+                associations =
+                  instance_variables.inject([]) do |associations, iv|
+                    if (iv =~ /^@#{options[:user_collection]}_/) == 0
+                      associations << iv
+                    end
+                    associations
+                  end
+                associations.each do |association_name|
+                  association = instance_variable_get("\#{association_name}")
+                  if association.respond_to?(:loaded?)
+                    if new_record?
+                      records_to_save = association
+                    else
+                      records_to_save = association.select do |record|
+                        record.new_record?
+                      end
+                    end
+                    records_to_save.inject(true) do |result,record|
+                      result &&= record.valid?
+                    end
+                  end
+                end
+              end_eval
+            end
+
+            module_eval do
+              after_callback = <<-end_eval
+                associations =
+                  instance_variables.inject([]) do |associations, iv|
+                    if (iv =~ /^@#{options[:user_collection]}_/) == 0
+                      associations << iv
+                    end
+                    associations
+                  end
+                associations.each do |association_name|
+                  association = instance_variable_get("\#{association_name}")
+                  if association.respond_to?(:loaded?)
+                    if @new_record_before_save
+                      records_to_save = association
+                    else
+                      records_to_save = association.select do |record|
+                        record.new_record?
+                      end
+                    end
+                    records_to_save.each do |record|
+                      association.send(:insert_record, record)
+                    end
+                    # reconstruct the SQL queries now that we know
+                    # the owner's id
+                    association.send(:construct_sql)
+                  end
+                end
+              end_eval
+
+              # Doesn't use after_save as that would save associations
+              # added in after_create/after_update twice
+              after_create(after_callback)
+              after_update(after_callback)
+            end
+                        
+            # When the item gets destroyed, clear out all relationships
+            # that reference it.
+            before_destroy_sql = "DELETE FROM #{options[:join_table]} " +
+              "WHERE #{item_foreign_key} = " +
+              "\\\#{self.quoted_id}"
+            module_eval(
+              "before_destroy \"self.connection.delete(" +
+              "%{#{before_destroy_sql}})\"")
+            
+            class_eval do
+              include ActiveRecord::Acts::Taggable::InstanceMethods
+            end
+
+          elsif options[:scope] == :global
+            
+            require_association(
+              Inflector.underscore(options[:tag_class_name]))
+
+            tag_class = eval(options[:tag_class_name])
+            item_class = self
+            
+            options[:join_table] ||=
+              join_table_name(
+                undecorated_table_name(tag_class.name),
+                undecorated_table_name(item_class.name))
+
+            define_method(options[:collection]) do |*params|
+              force_reload = params.first unless params.empty?
+              association = instance_variable_get(
+                "@#{options[:collection]}")
+              unless association.respond_to?(:loaded?)
+                association =
+                  ActiveRecord::Associations::GlobalTagsAssociation.new(self,
+                    tag_class, item_class, options)
+                instance_variable_set(
+                  "@#{options[:collection]}", association)
+              end
+              association.reload if force_reload
+              return association
+            end
+            
+            singleton_class = class << self; self; end
+            singleton_class.module_eval do
+              define_method(:tag_query) do |*params|
+                query_options = params.first unless params.empty?
+                validate_options([:with_any_tags, :with_all_tags,
+                  :without_tags], query_options.keys)
+                with_any_tags = query_options[:with_any_tags]
+                unless with_any_tags.nil?
+                  with_any_tags.collect! { |tag| tag.to_s }
+                  with_any_tags.uniq!
+                end
+                with_all_tags = query_options[:with_all_tags]
+                unless with_all_tags.nil?
+                  with_all_tags.collect! { |tag| tag.to_s }
+                  with_all_tags.uniq!
+                end
+                without_tags = query_options[:without_tags]
+                unless without_tags.nil?
+                  without_tags.collect! { |tag| tag.to_s }
+                  without_tags.uniq!
+                end
+                if without_tags != nil && with_any_tags == nil &&
+                    with_all_tags == nil
+                  raise(ActiveRecord::ActiveRecordError,
+                    "Cannot run this query, nothing to search for.")
+                end
+                results = []
+
+                group_by_string = item_class.table_name + "." +
+                  item_class.column_names.join(
+                    ", #{item_class.table_name}.")
+
+                with_all_tags_results = nil
+                if with_all_tags != nil && with_all_tags.size > 0
+                  with_all_tags_query_thread = Thread.new do
+                    tag_name_condition = "#{tag_class.table_name}.name = '" +
+                      with_all_tags.join(
+                        "\' OR #{tag_class.table_name}.name=\'") + "'"
+                    with_all_tags_sql = <<-SQL
+                      SELECT #{item_class.table_name}.*
+                      FROM #{options[:join_table]}, #{item_class.table_name},
+                        #{tag_class.table_name}
+                      WHERE #{options[:join_table]}.#{tag_foreign_key} =
+                        #{tag_class.table_name}.#{tag_class.primary_key}
+                      AND (#{tag_name_condition})
+                      AND #{item_class.table_name}.#{item_class.primary_key} =
+                        #{options[:join_table]}.#{item_foreign_key}
+                      GROUP BY #{group_by_string}
+                      HAVING COUNT(
+                        #{item_class.table_name}.#{item_class.primary_key}) =
+                        #{with_all_tags.size}
+                    SQL
+                    with_all_tags_results =
+                      item_class.find_by_sql(with_all_tags_sql)
+                  end
+                end
+
+                with_any_tags_results = nil
+                if with_any_tags != nil && with_any_tags.size > 0
+                  with_any_tags_query_thread = Thread.new do
+                    with_any_tags_sql = <<-SQL
+                      SELECT #{item_class.table_name}.*
+                      FROM #{options[:join_table]}, #{item_class.table_name},
+                        #{tag_class.table_name}
+                      WHERE #{tag_class.table_name}.name
+                      IN ('#{with_any_tags.join('\', \'')}')
+                      AND #{tag_class.table_name}.#{tag_class.primary_key} =
+                        #{options[:join_table]}.#{tag_foreign_key}
+                      AND #{item_class.table_name}.#{item_class.primary_key} =
+                        #{options[:join_table]}.#{item_foreign_key}
+                      GROUP BY #{group_by_string}
+                    SQL
+                    with_any_tags_results =
+                      item_class.find_by_sql(with_any_tags_sql)
+                  end
+                end
+
+                if with_all_tags != nil && with_all_tags.size > 0
+                  with_all_tags_query_thread.join
+                end
+                if with_any_tags != nil && with_any_tags.size > 0
+                  with_any_tags_query_thread.join
+                end
+                if with_any_tags_results != nil &&
+                    with_any_tags_results.size > 0 &&
+                    with_all_tags_results != nil &&
+                    with_all_tags_results.size > 0
+                  results = with_all_tags_results & with_any_tags_results
+                elsif with_any_tags_results != nil &&
+                    with_any_tags_results.size > 0
+                  results = with_any_tags_results
+                elsif with_all_tags_results != nil &&
+                    with_all_tags_results.size > 0
+                  results = with_all_tags_results
+                end
+                if without_tags != nil && without_tags.size > 0
+                  for result in results
+                    if ((result.tags.map { |tag| tag.name }) &
+                        without_tags).size > 0
+                      results.delete(result)
+                    end
+                  end
+                end
+                return results
+              end
+            end
+            
+            module_eval do
+              before_save <<-end_eval
+                @new_record_before_save = new_record?
+                association =
+                  instance_variable_get("@#{options[:collection]}")
+                if association.respond_to?(:loaded?)
+                  if new_record?
+                    records_to_save = association
+                  else
+                    records_to_save = association.select do |record|
+                      record.new_record?
+                    end
+                  end
+                  records_to_save.inject(true) do |result,record|
+                    result &&= record.valid?
+                  end
+                end
+              end_eval
+            end
+
+            module_eval do
+              after_callback = <<-end_eval
+                association =
+                  instance_variable_get("@#{options[:collection]}")
+                if association.respond_to?(:loaded?)
+                  if @new_record_before_save
+                    records_to_save = association
+                  else
+                    records_to_save = association.select do |record|
+                      record.new_record?
+                    end
+                  end
+                  records_to_save.each do |record|
+                    association.send(:insert_record, record)
+                  end
+                  # reconstruct the SQL queries now that we know
+                  # the owner's id
+                  association.send(:construct_sql)
+                end
+              end_eval
+
+              # Doesn't use after_save as that would save associations
+              # added in after_create/after_update twice
+              after_create(after_callback)
+              after_update(after_callback)
+            end
+
+            # When the item gets destroyed, clear out all relationships
+            # that reference it.
+            before_destroy_sql = "DELETE FROM #{options[:join_table]} " +
+              "WHERE #{item_foreign_key} = " +
+              "\\\#{self.quoted_id}"
+            module_eval(
+              "before_destroy \"self.connection.delete(" +
+              "%{#{before_destroy_sql}})\"")
+
+            class_eval do
+              include ActiveRecord::Acts::Taggable::InstanceMethods
+            end
+          end
+        end
+        private
+        
+      private
+        # Raises an exception if an invalid option has been specified to
+        # prevent misspellings from slipping through 
+        def validate_options(valid_option_keys, supplied_option_keys)
+          unknown_option_keys = supplied_option_keys - valid_option_keys
+          unless unknown_option_keys.empty?
+            raise(ActiveRecord::ActiveRecordError,
+              "Unknown options: #{unknown_option_keys}")
+          end
+        end
+
+        def join_table_name(*table_names)
+          table_name_prefix + table_names.sort.join("_") + table_name_suffix
+        end
+      end      
+      
+      module InstanceMethods
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include ActiveRecord::Acts::Taggable
+end