tagtools 0.0.2 → 0.0.3

data/CHANGELOG

@@ -1,3 +1,7 @@
+== TagTools 0.0.3
+ * fixed a particularly nasty bug with tag queries on user-scoped tags
+ * added a mixin for tag classes
+ * improved the unit tests
 == TagTools 0.0.2
  * fixed a bug in delete_records for user tag collections
  * added include? method to all tag collections

data/lib/tagtools.rb

@@ -21,7 +21,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-TAG_TOOLS_VERSION = "0.0.2"
+TAG_TOOLS_VERSION = "0.0.3"
 
 $:.unshift(File.dirname(__FILE__))
 $:.unshift(File.dirname(__FILE__) + "/../../activerecord/lib")
@@ -539,6 +539,23 @@ module ActiveRecord #:nodoc:
                 undecorated_table_name(tag_class.name),
                 undecorated_table_name(user_class.name),
                 undecorated_table_name(item_class.name))
+                
+            association_hash = {
+              :tag_class => tag_class,
+              :tag_foreign_key => tag_foreign_key,
+              :item_class => item_class,
+              :item_foreign_key => item_foreign_key,
+              :user_class => user_class,
+              :user_foreign_key => user_foreign_key,
+              :join_table => options[:join_table]
+            }
+            
+            if tag_class.instance_variable_get("@tagged_classes").nil?
+              tag_class.instance_variable_set("@tagged_classes", [])
+            end
+            tagged_classes =
+              tag_class.instance_variable_get("@tagged_classes")
+            tagged_classes << association_hash
             
             # Create the two collections
             define_method(options[:collection]) do |*params|
@@ -579,8 +596,15 @@ module ActiveRecord #:nodoc:
             singleton_class.module_eval do
               define_method(:tag_query) do |*params|
                 query_options = params.first unless params.empty?
+                unless query_options.kind_of? Hash
+                  raise "The first parameter must be a hash."
+                end
                 validate_options([:with_any_tags, :with_all_tags,
                   :without_tags, :user_id], query_options.keys)
+                if query_options.size == 0
+                  raise "You must supply either the with_any_tags option, " +
+                    "the with_all_tags option, or both."
+                end
                 with_any_tags = query_options[:with_any_tags]
                 unless with_any_tags.nil?
                   with_any_tags.collect! { |tag| tag.to_s }
@@ -616,57 +640,58 @@ module ActiveRecord #:nodoc:
 
                 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)
+                  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)
+                  if tagging_user_id.nil?
+                    for result in with_all_tags_results
+                      result_tags = result.tags.map do |tag|
+                        tag.name
+                      end
+                      if (result_tags & with_all_tags).size != with_all_tags.size
+                        # Reject result
+                        with_all_tags_results.delete(result)
+                      end
+                    end
                   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
+                  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
 
-                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 &&
@@ -679,11 +704,19 @@ module ActiveRecord #:nodoc:
                     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)
+                    if tagging_user_id.nil?
+                      if ((result.tags.map { |tag| tag.name }) &
+                          without_tags).size > 0
+                        results.delete(result)
+                      end
+                    else
+                      if ((result.user_tags(tagging_user_id).map { |tag| tag.name }) &
+                          without_tags).size > 0
+                        results.delete(result)
+                      end
                     end
                   end
                 end
@@ -780,6 +813,23 @@ module ActiveRecord #:nodoc:
                 undecorated_table_name(tag_class.name),
                 undecorated_table_name(item_class.name))
 
+            association_hash = {
+              :tag_class => tag_class,
+              :tag_foreign_key => tag_foreign_key,
+              :item_class => item_class,
+              :item_foreign_key => item_foreign_key,
+              :user_class => nil,
+              :user_foreign_key => nil,
+              :join_table => options[:join_table]
+            }
+            
+            if tag_class.instance_variable_get("@tagged_classes").nil?
+              tag_class.instance_variable_set("@tagged_classes", [])
+            end
+            tagged_classes =
+              tag_class.instance_variable_get("@tagged_classes")
+            tagged_classes << association_hash
+            
             define_method(options[:collection]) do |*params|
               force_reload = params.first unless params.empty?
               association = instance_variable_get(
@@ -799,8 +849,15 @@ module ActiveRecord #:nodoc:
             singleton_class.module_eval do
               define_method(:tag_query) do |*params|
                 query_options = params.first unless params.empty?
+                unless query_options.kind_of? Hash
+                  raise "The first parameter must be a hash."
+                end
                 validate_options([:with_any_tags, :with_all_tags,
-                  :without_tags], query_options.keys)
+                  :without_tags, :user_id], query_options.keys)
+                if query_options.size == 0
+                  raise "You must supply either the with_any_tags option, " +
+                    "the with_all_tags option, or both."
+                end
                 with_any_tags = query_options[:with_any_tags]
                 unless with_any_tags.nil?
                   with_any_tags.collect! { |tag| tag.to_s }
@@ -829,55 +886,45 @@ module ActiveRecord #:nodoc:
 
                 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
+                  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
 
                 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
+                  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
 
-                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 &&
@@ -987,6 +1034,214 @@ module ActiveRecord #:nodoc:
   end
 end
 
+# This module allows you to add additional generic functionality to your
+# Tag class by simply extending the TaggingHelpers module.
+#
+# Example:
+#  class Tag < ActiveRecord::Base
+#    extend TaggingHelpers
+#  end
+module TaggingHelpers
+  # Unlike the tag_query class method on tagged classes, this will search
+  # across the entire tagged space, returning any tagged object, regardless
+  # of type, that matches the query criteria.
+  # 
+  # Options are:
+  # * <tt>:with_all_tags</tt> - An array of strings, returns all tagged
+  #   objects that have all of the tags specified within the array.
+  # * <tt>:with_any_tags</tt> - An array of strings, returns all tagged
+  #   objects that have any of the tags specified within the array.
+  # * <tt>:without_tags</tt> - An array of strings, removes all tagged
+  #   objects that have any of the tags specified within the array from
+  #   the list of results that would have otherwise been returned.
+  #   Throws an error if used in the absence of of either of the other
+  #   two options.
+  # * <tt>:user_id</tt> - An integer id for the user that this query
+  #   is specific to.  Only tags that this user has created will be
+  #   taken into account with this query.  Globally scoped tag associations
+  #   will be not be included in the results if this option is set.
+  def tag_query(options = {})
+    if self.class != Class
+      raise "You must extend your tag class with the TaggingHelpers module."
+    end
+    unless options.kind_of? Hash
+      raise "The options parameter must be a hash."
+    end
+    validate_options([:with_any_tags, :with_all_tags,
+      :without_tags, :user_id], options.keys)
+    if options.size == 0
+      raise "You must supply either the with_any_tags option, " +
+        "the with_all_tags option, or both."
+    end
+    with_any_tags = 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 = options[:with_all_tags]
+    unless with_all_tags.nil?
+      with_all_tags.collect! { |tag| tag.to_s }
+      with_all_tags.uniq!
+    end
+    without_tags = 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 = options[:user_id]
+    results = []
+    
+    for association_hash in self.instance_variable_get("@tagged_classes")
+      
+      # Load variables from the association_hash
+      tag_class = association_hash[:tag_class]
+      tag_foreign_key = association_hash[:tag_foreign_key]
+      item_class = association_hash[:item_class]
+      item_foreign_key = association_hash[:item_foreign_key]
+      user_class = association_hash[:user_class]
+      user_foreign_key = association_hash[:user_foreign_key]
+      join_table = association_hash[:join_table]
+      
+      # If they specified a user_id, and this association is a globally
+      # scoped tag association, skip to the next association.
+      if tagging_user_id != nil && user_class.nil?
+        next
+      end
+            
+      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 #{join_table}.#{user_foreign_key} = #{tagging_user_id}"
+      end
+
+      with_all_tags_results = nil
+      if with_all_tags != nil && with_all_tags.size > 0
+        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 #{join_table}, #{item_class.table_name},
+            #{tag_class.table_name}
+          WHERE #{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} =
+            #{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)
+        if tagging_user_id.nil?
+          for result in with_all_tags_results
+            result_tags = result.tags.map do |tag|
+              tag.name
+            end
+            if (result_tags & with_all_tags).size != with_all_tags.size
+              # Reject result
+              with_all_tags_results.delete(result)
+            end
+          end
+        end
+      end
+
+      with_any_tags_results = nil
+      if with_any_tags != nil && with_any_tags.size > 0
+        with_any_tags_sql = <<-SQL
+          SELECT #{item_class.table_name}.*
+          FROM #{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} =
+            #{join_table}.#{tag_foreign_key}
+          AND #{item_class.table_name}.#{item_class.primary_key} =
+            #{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
+
+      if with_any_tags_results != nil &&
+          with_any_tags_results.size > 0 &&
+          with_all_tags_results != nil &&
+          with_all_tags_results.size > 0
+        results.concat(with_all_tags_results & with_any_tags_results)
+      elsif with_any_tags_results != nil &&
+          with_any_tags_results.size > 0
+        results.concat(with_any_tags_results)
+      elsif with_all_tags_results != nil &&
+          with_all_tags_results.size > 0
+        results.concat(with_all_tags_results)
+      end
+    end
+  
+    if without_tags != nil && without_tags.size > 0
+      for result in results
+        if tagging_user_id.nil?
+          if ((result.tags.map { |tag| tag.name }) &
+              without_tags).size > 0
+            results.delete(result)
+          end
+        else
+          if ((result.user_tags(tagging_user_id).map { |tag| tag.name }) &
+              without_tags).size > 0
+            results.delete(result)
+          end
+        end
+      end
+    end
+    return results
+  end
+  
+  # Takes a string and converts it to a tag object, creating the tag object
+  # if it doesn't yet exist.
+  def create_tag(raw_tag)
+    if self.class != Class
+      raise "You must extend your tag class with the TaggingHelpers module."
+    end
+    return nil if raw_tag.nil?
+    if raw_tag.kind_of? self
+      return raw_tag
+    end
+    tag_object = self.find_by_name(raw_tag.to_s)
+    if tag_object.nil?
+      tag_object = self.new
+      tag_object.name = raw_tag.to_s
+      tag_object.save
+    end
+    return tag_object
+  end
+
+  # Takes a string and converts it to a tag object, returning nil if it
+  # doesn't yet exist.
+  def get_tag(raw_tag)
+    if self.class != Class
+      raise "You must extend your tag class with the TaggingHelpers module."
+    end
+    return nil if raw_tag.nil?
+    if raw_tag.kind_of? self
+      return raw_tag
+    end
+    tag_object = self.find_by_name(raw_tag.to_s)
+    return tag_object
+  end
+end
+
 ActiveRecord::Base.class_eval do
   include ActiveRecord::Acts::Taggable
 end

data/rakefile

@@ -7,7 +7,7 @@ require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
 
 PKG_NAME      = 'tagtools'
-PKG_VERSION   = '0.0.2'
+PKG_VERSION   = '0.0.3'
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"

data/test/global_tags_test.rb

@@ -31,6 +31,7 @@ rescue
 end
 
 class Tag < ActiveRecord::Base
+  extend TaggingHelpers
 end
 
 class Image < ActiveRecord::Base
@@ -44,6 +45,12 @@ class GlobalTagsTest < Test::Unit::TestCase
     ActiveRecord::Base.connection.execute("DELETE FROM tags")
   end
 
+  def teardown
+    ActiveRecord::Base.connection.execute("DELETE FROM images_tags")
+    ActiveRecord::Base.connection.execute("DELETE FROM images")
+    ActiveRecord::Base.connection.execute("DELETE FROM tags")
+  end
+
   def test_add_tags_existing_record
     ruby_on_rails = Image.new
     ruby_on_rails.url = "http://www.rubyonrails.com/logo.gif"
@@ -142,4 +149,39 @@ class GlobalTagsTest < Test::Unit::TestCase
     assert_equal(2,
       ruby_on_rails.tags(true).size)
   end
+  
+  def test_tag_helpers
+    ruby_on_rails = Image.new
+    ruby_on_rails.url = "http://www.rubyonrails.com/logo.gif"
+    ruby_on_rails.save
+    ruby_on_rails.tags << "ruby"
+    ruby_on_rails.tags << "rails"
+    ruby_on_rails.tags << "framework"
+    red_handed = Image.new
+    red_handed.url = "http://redhanded.hobix.com/logo.gif"
+    red_handed.save
+    red_handed.tags << "ruby"
+    red_handed.tags << "cult"
+
+    tag = Tag.get_tag("ruby")
+    assert_equal("ruby", tag.name)
+    tag = Tag.get_tag("non-existant")
+    assert_equal(nil, tag)
+    tag = Tag.create_tag("ruby")
+    assert_equal("ruby", tag.name)
+    tag = Tag.create_tag("non-existant")
+    assert_equal("non-existant", tag.name)
+
+    results = Tag.tag_query(:with_all_tags => ["ruby", "cult"])
+    assert_equal(red_handed, results.first)
+    results = Tag.tag_query(:with_all_tags => ["ruby", "framework"])
+    assert_equal(ruby_on_rails, results.first)
+    results = Tag.tag_query(:with_any_tags => ["cult", "framework"])
+    assert(results.include?(ruby_on_rails))
+    assert(results.include?(red_handed))
+    results = Tag.tag_query(:with_all_tags => ["ruby", "framework"],
+      :without_tags => ["cult"])
+    assert_equal(ruby_on_rails, results.first)
+    assert(!results.include?(red_handed))
+  end
 end

data/test/user_tags_test.rb

@@ -34,6 +34,7 @@ class User < ActiveRecord::Base
 end
 
 class Tag < ActiveRecord::Base
+  extend TaggingHelpers  
 end
 
 class Bookmark < ActiveRecord::Base
@@ -48,6 +49,13 @@ class UserTagsTest < Test::Unit::TestCase
     ActiveRecord::Base.connection.execute("DELETE FROM users")
     ActiveRecord::Base.connection.execute("DELETE FROM tags")
   end
+  
+  def teardown
+    ActiveRecord::Base.connection.execute("DELETE FROM bookmarks_tags_users")
+    ActiveRecord::Base.connection.execute("DELETE FROM bookmarks")
+    ActiveRecord::Base.connection.execute("DELETE FROM users")
+    ActiveRecord::Base.connection.execute("DELETE FROM tags")
+  end
     
   def test_add_tags_existing_record
     some_guy = User.new
@@ -90,6 +98,9 @@ class UserTagsTest < Test::Unit::TestCase
     some_guy = User.new
     some_guy.name = "Joe Normal"
     some_guy.save
+    some_other_guy = User.new
+    some_other_guy.name = "Joe Abnormal"
+    some_other_guy.save
     ruby_on_rails = Bookmark.new
     ruby_on_rails.url = "http://www.rubyonrails.com"
     ruby_on_rails.save
@@ -101,17 +112,40 @@ class UserTagsTest < Test::Unit::TestCase
     red_handed.save
     red_handed.user_tags(some_guy.id) << "ruby"
     red_handed.user_tags(some_guy.id) << "cult"
+    red_handed.user_tags(some_other_guy.id) << "spinach"
+    red_handed.user_tags(some_other_guy.id) << "turkey"
+    red_handed.user_tags(some_other_guy.id) << "atlantis"
+    red_handed.user_tags(some_other_guy.id) << "ruby"
+        
     results = Bookmark.tag_query(:with_all_tags => ["ruby", "cult"])
     assert_equal(red_handed, results.first)
+    assert_equal(1, results.size)
     results = Bookmark.tag_query(:with_all_tags => ["ruby", "framework"])
     assert_equal(ruby_on_rails, results.first)
+    assert_equal(1, results.size)
     results = Bookmark.tag_query(:with_any_tags => ["cult", "framework"])
     assert(results.include?(ruby_on_rails))
     assert(results.include?(red_handed))
+    assert_equal(2, results.size)
     results = Bookmark.tag_query(:with_all_tags => ["ruby", "framework"],
       :without_tags => ["cult"])
     assert_equal(ruby_on_rails, results.first)
     assert(!results.include?(red_handed))
+    assert_equal(1, results.size)
+    results = Bookmark.tag_query(:with_all_tags => ["ruby", "framework"],
+      :without_tags => ["cult"], :user_id => some_guy.id)
+    assert_equal(ruby_on_rails, results.first)
+    assert(!results.include?(red_handed))
+    assert_equal(1, results.size)
+    results = Bookmark.tag_query(:with_all_tags => ["spinach"],
+      :with_any_tags => ["ruby", "cult", "rails", "framework"],
+      :without_tags => ["cult"], :user_id => some_other_guy.id)
+    assert_equal(red_handed, results.first)
+    assert(!results.include?(ruby_on_rails))
+    assert_equal(1, results.size)
+    results = Bookmark.tag_query(:with_all_tags => ["ruby", "framework"],
+      :without_tags => ["cult"], :user_id => -1)
+    assert_equal(0, results.size)
   end
   
   def test_include
@@ -161,4 +195,69 @@ class UserTagsTest < Test::Unit::TestCase
     assert_equal(2,
       ruby_on_rails.user_tags(some_guy.id, true).size)
   end
+  
+  def test_tag_helpers
+    some_guy = User.new
+    some_guy.name = "Joe Normal"
+    some_guy.save
+    some_other_guy = User.new
+    some_other_guy.name = "Joe Abnormal"
+    some_other_guy.save
+    ruby_on_rails = Bookmark.new
+    ruby_on_rails.url = "http://www.rubyonrails.com"
+    ruby_on_rails.save
+    ruby_on_rails.user_tags(some_guy.id) << "ruby"
+    ruby_on_rails.user_tags(some_guy.id) << "rails"
+    ruby_on_rails.user_tags(some_guy.id) << "framework"
+    red_handed = Bookmark.new
+    red_handed.url = "http://redhanded.hobix.com"
+    red_handed.save
+    red_handed.user_tags(some_guy.id) << "ruby"
+    red_handed.user_tags(some_guy.id) << "cult"
+    red_handed.user_tags(some_other_guy.id) << "spinach"
+    red_handed.user_tags(some_other_guy.id) << "turkey"
+    red_handed.user_tags(some_other_guy.id) << "atlantis"
+    red_handed.user_tags(some_other_guy.id) << "ruby"
+
+    tag = Tag.get_tag("ruby")
+    assert_equal("ruby", tag.name)
+    tag = Tag.get_tag("non-existant")
+    assert_equal(nil, tag)
+    tag = Tag.create_tag("ruby")
+    assert_equal("ruby", tag.name)
+    tag = Tag.create_tag("non-existant")
+    assert_equal("non-existant", tag.name)
+
+    results = Tag.tag_query(:with_all_tags => ["ruby", "cult"])
+    assert_equal(red_handed, results.first)
+    assert_equal(1, results.size)
+    $foo = true
+    results = Tag.tag_query(:with_all_tags => ["ruby", "framework"])
+    $foo = false
+    assert_equal(ruby_on_rails, results.first)
+    assert_equal(1, results.size)
+    results = Tag.tag_query(:with_any_tags => ["cult", "framework"])
+    assert(results.include?(ruby_on_rails))
+    assert(results.include?(red_handed))
+    assert_equal(2, results.size)
+    results = Tag.tag_query(:with_all_tags => ["ruby", "framework"],
+      :without_tags => ["cult"])
+    assert_equal(ruby_on_rails, results.first)
+    assert(!results.include?(red_handed))
+    assert_equal(1, results.size)
+    results = Tag.tag_query(:with_all_tags => ["ruby", "framework"],
+      :without_tags => ["cult"], :user_id => some_guy.id)
+    assert_equal(ruby_on_rails, results.first)
+    assert(!results.include?(red_handed))
+    assert_equal(1, results.size)
+    results = Tag.tag_query(:with_all_tags => ["spinach"],
+      :with_any_tags => ["ruby", "cult", "rails", "framework"],
+      :without_tags => ["cult"], :user_id => some_other_guy.id)
+    assert_equal(red_handed, results.first)
+    assert(!results.include?(ruby_on_rails))
+    assert_equal(1, results.size)
+    results = Tag.tag_query(:with_all_tags => ["ruby", "framework"],
+      :without_tags => ["cult"], :user_id => -1)
+    assert_equal(0, results.size)
+  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: tagtools
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2005-09-09 00:00:00 -04:00
+  version: 0.0.3
+date: 2005-09-21 00:00:00 -04:00
 summary: Folksonomy system for Rails.
 require_paths: 
   - lib