yoomee-acts_as_mongo_taggable 0.2.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+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.markdown

@@ -0,0 +1,102 @@
+ActsAsMongoTaggable
+===================
+
+Inspired by mbleigh's "acts_as_taggable_on," this tagging plugin works with MongoDB+MongoMapper.
+
+Intends to be super-performant by taking advantage of the benefits of document-driven db denormalization.
+
+Requirements
+------------
+
+- MongoDB
+- MongoMapper gem
+- Expects you to have a User model that includes MongoMapper::Document
+
+Installation
+------------
+
+Best practice -- install the gem:
+
+    gem install acts_as_mongo_taggable
+
+… and add a line to your environment.rb:
+
+    config.gem 'acts_as_mongo_taggable'
+
+
+or, if you're old-school, install as a plugin:
+        
+    ./script/plugin install git://github.com/mepatterson/acts_as_mongo_taggable.git
+
+
+Finally, add this line to the Rails model class that you want to make taggable:
+
+    include ActsAsMongoTaggable
+
+Yeah, that's it.
+
+Usage
+-----
+
+    class User
+      include MongoMapper::Document
+    end
+
+    class Widget
+      include MongoMapper::Document
+      include ActsAsMongoTaggable
+    end
+
+To rate it:
+
+    widget.tag(word_or_words, user)
+
+- word_or_words can be a string, a string of comma-delimited words, or an array
+- user is the User who is tagging this widget
+
+Basic search:
+
+    Widget.find_with_tag('vampires')
+
+... will return the first Widget object that has been tagged with that phrase
+
+    Widget.find_all_with_tag('vampires')
+
+... will return an array of Widget objects, all of which have been tagged with that phrase
+
+    Widget.most_tagged_with('vampires')
+    
+... will return the Widget object that has been tagged the most times with that phrase
+
+Making tag clouds:
+
+    Widget.all_tags_with_counts
+    
+... will return a nice array of arrays, a la [["rails", 8],["ruby", 12], ["php", 6], ["java", 2]]
+Use this to make yourself a tag cloud for now. (maybe I'll implement a tag cloud view helper someday.)
+
+Statistics on Tags:
+
+    Tag.top_25
+
+... returns the top 25 most used tags across all taggable object classes in the system
+
+    Tag.top_25("Widget")
+
+... returns the top 25 most used tags for Widget objects
+
+
+Future
+------
+- Performance improvements as I come across the need
+
+
+Thanks To...
+------------
+- Jon Bell for some sweet refactorings and gem-ification
+- John Nunemaker and the rest of the folks on the MongoMapper Google Group
+- Kyle Banker and his excellent blog posts on grouping and aggregation
+- The MongoDB peoples and the MongoDB Google Group
+- mbleigh for the acts_as_taggable_on plugin for ActiveRecord
+
+Copyright (c) 2009 [M. E. Patterson], released under the MIT license

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the acts_as_mongo_taggable_on plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_mongo_taggable_on plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsMongoTaggableOn'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  GEM = "acts_as_mongo_taggable"
+  AUTHOR = "Matt E. Patterson"
+  EMAIL = "mpatterson@ngenera.com"
+  SUMMARY = "A ruby gem for acts_as_taggable to mongo"
+  HOMEPAGE = "http://github.com/mepatterson/acts_as_mongo_taggable"
+  
+  gem 'jeweler', '>= 1.0.0'
+  require 'jeweler'
+  
+  Jeweler::Tasks.new do |s|
+    s.name = GEM
+    s.summary = SUMMARY
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.description = SUMMARY
+    s.author = AUTHOR
+    
+    s.require_path = 'lib'
+    s.files = %w(MIT-LICENSE README.textile Rakefile) + Dir.glob("{rails,lib,generators,spec}/**/*")
+    
+    # Runtime dependencies: When installing Formtastic these will be checked if they are installed.
+    # Will be offered to install these if they are not already installed.
+    s.add_dependency 'mongo_mapper', '>= 0.7.0'
+    
+    # Development dependencies. Not installed by default.
+    # Install with: sudo gem install formtastic --development
+    #s.add_development_dependency 'rspec-rails', '>= 1.2.6'
+  end
+  
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "[acts_as_mongo_taggable:] Jeweler - or one of its dependencies - is not available. Install it with: sudo gem install jeweler -s http://gemcutter.org"
+end

data/lib/acts_as_mongo_taggable.rb

@@ -0,0 +1,256 @@
+module ActsAsMongoTaggable
+  module ClassMethods
+    def all_tags_with_counts
+      Tag.most_tagged(self).map{|tag| [tag.word, tag.count_for(self)]}
+    end
+    
+    # returns the _first_ widget with this tag, a la ActiveRecord find()
+    # note: case-insensitive unless you specify otherwise with :case_sensitive=>true
+    def first_with_tag(phrase, opts={})
+      lo = opts.clone
+      case_sensitive = lo.delete :case_sensitive
+      phrase = phrase.downcase unless case_sensitive
+      first(lo.merge(:tag_words => phrase))
+    end
+    
+    
+    def all_with_tag(phrase, opts={})
+      lo = opts.clone
+      case_sensitive = lo.delete :case_sensitive
+      phrase = phrase.downcase unless case_sensitive
+      all(lo.merge(:tag_words => phrase))
+    end
+    
+    def most_tagged_with(phrase, opts={})
+      lo = opts.clone
+      case_sensitive = lo.delete :case_sensitive
+      phrase = phrase.downcase unless case_sensitive
+      
+      #Doesn't work :(
+      #first(lo.merge('model_tags.word' => phrase, :order => 'model_tags.tagging_count desc'))
+      
+      all_with_tag(phrase, lo).sort do |a, b|
+        b.model_tag(phrase, opts).tagging_count <=> a.model_tag(phrase, opts).tagging_count
+      end.first
+    end
+    
+    def top_25_tags
+      Tag.top_25(self)
+    end
+  end
+  
+  module InstanceMethods
+    
+    def delete_all_tags
+      Tag.find(tag_ids).each do |tag|
+        model_taggings = tag.taggings.select{|tagging| tagging.taggable_type == self.class.name && tagging.taggable_id == self.id}
+        model_taggings.each{|tagging| tag.taggings.delete tagging}
+        tag.save_or_destroy
+      end
+      update_attributes({ :model_tags => [], :tag_words => [] })
+    end
+    
+    def _tags
+      Tag.find(:all, tag_ids)
+    end
+    
+    # returns array of tags and counts: 
+    #   [["matt", 3], ["bob", 2], ["bill", 1], ["joe", 1], ["frank", 1]]
+    def tags_with_counts
+      counts = model_tags.map{|tag| [tag.word, tag.tagging_count]}
+      counts.sort{|a, b| b[1] <=> a[1]}
+    end
+    
+    # returns an array of ids and user_ids
+    def tags_with_user_ids
+      model_tags.inject([]) do |arr, tag|
+        tag.user_ids.each{|user_id| arr << [tag.id, user_id]}
+        arr
+      end
+    end
+    
+    def tag_words_by_user(user)
+      tags_by_user(user).map(&:word)
+    end
+    
+    def tags_by_user(user)
+      model_tags.select{|tag| tag.user_ids.include? user.id}
+    end
+    
+    # returns only the tag words, sorted by frequency; optionally can be limited
+    def tags(limit=nil)
+      array = tags_with_counts
+      limit ||= array.size
+      array[0,limit].map{|t| t[0]}
+    end
+    
+    def model_tag(phrase, opts = {})
+      phrase = phrase.downcase unless opts[:case_sensitive]
+      model_tags.detect{|tag| tag.word == phrase}
+    end
+    
+    def tag_ids
+      model_tags.map(&:tag_id)
+    end
+  end
+  
+  def delete_tags_by_user(user)
+    return false unless user
+    return 0 if model_tags.blank?
+    user_tags = tags_by_user(user)
+    
+    Tag.find(user_tags.map(&:tag_id)).each do |tag|
+      user_taggings = tag.taggings.select{|tagging| tagging.user_id == user.id && tagging.taggable_type == self.class.name && tagging.taggable_id == self.id}
+      user_taggings.each{|tagging| tag.taggings.delete tagging}
+      tag.save_or_destroy
+    end
+    
+    user_tags.each do |tag| 
+      tag.users.delete user
+      destroy_if_empty(tag)
+    end
+    save
+    reload
+  end
+  
+  def arr_of_words(words)
+    raise "Passed an invalid data type to tag()" unless words.is_a?(String) || words.is_a?(Array)
+    if words.is_a?(String)
+      words.squish.split(',').map{|w| w.squish}
+    else
+      words.map{|w| w.squish}
+    end
+  end
+  
+  # returns my current tag word list; with optional user, raises exception if user tries to 
+  # multi-tag with same word when user specified or if duplicate tag
+  def tag!(word_or_words, options={})
+    user = options[:user]
+    arr_of_words(word_or_words).each do |word|
+      word = word.downcase unless options[:case_sensitive] == true
+      raise StandardError if (user && tag_words_by_user(user).include?(word)) || (model_tag = model_tags.detect{|tag| tag.word == word})
+      
+      if user || !model_tag
+        #First add Tag/Tagging
+        t = Tag.first(:word => word) || Tag.create!(:word => word)
+        t.taggings << Tagging.new(:user => user, :taggable => self)
+        t.save
+      end
+    
+      #Now add ModelTag/User/tag_word
+      unless model_tag
+        model_tag = ModelTag.new(:word => word, :tag => t)
+        self.model_tags << model_tag
+        self.tag_words << word
+      end
+      model_tag.users << user if user
+    end
+    save!
+    tags
+  end
+  
+  # tags, with optional user, but silently ignores if user tries to multi-tag with same word
+  # NOTE: automatically downcases each word unless you manually specify :case_sensitive=>true
+  def tag(word_or_words, options={})
+    user = options[:user]
+    arr_of_words(word_or_words).each do |word|
+      word = word.downcase unless options[:case_sensitive] == true
+      if user.nil? || (user && !tag_words_by_user(user).include?(word))
+        model_tag = model_tags.detect{|tag| tag.word == word}
+        
+        if user || !model_tag
+          #First add Tag/Tagging
+          t = Tag.first(:word => word) || Tag.create!(:word => word)
+          t.taggings << Tagging.new(:user => user, :taggable => self)
+          t.save
+        end
+      
+        #Now add ModelTag/User/tag_word
+        unless model_tag
+          model_tag = ModelTag.new(:word => word, :tag => t)
+          self.model_tags << model_tag
+          self.tag_words << word
+        end
+        model_tag.users << user if user
+      end
+    end
+    save
+    tags
+  end
+  
+  # tags anonymously, not associated with user. Doesn't allow duplicate tags.
+  # NOTE: automatically downcases each word unless you manually specify :case_sensitive=>true
+  # def tag(word_or_words, opts={})
+  #     arr_of_words(word_or_words).each do |word|
+  #       word = word.downcase unless opts[:case_sensitive] == true
+  #       unless model_tags.any?{|tag| tag.word == word}
+  #         #First add Tag/Tagging
+  #         t = Tag.first(:word => word) || Tag.create!(:word => word)
+  #         t.taggings << Tagging.new(:taggable => self)
+  #         t.save
+  # 
+  #         model_tag = ModelTag.new(:word => word, :tag => t)
+  #         self.model_tags << model_tag
+  #         self.tag_words << word
+  #       end
+  #     end
+  #     save
+  #     tags
+  #   end
+  
+  
+  # returns the Rating object found if user has rated this project, else returns nil
+  def tagged_by_user?(user)
+    !(model_tags.detect{|tag| tag.user_ids.include?(user.id)}.nil?)
+  end
+  
+  # removes tag and all taggings from object 
+  # NOTE: automatically downcases each word unless you manually specify :case_sensitive=>true
+  def untag(word_or_words, opts={})
+    arr_of_words(word_or_words).each do |word|
+      word = word.downcase unless opts[:case_sensitive] == true
+      model_tag = model_tags.detect{|tag| tag.word == word}
+      if model_tag
+        tag = model_tag.tag
+        taggings = tag.taggings.select{|tagging| tagging.taggable_type == self.class.name && tagging.taggable_id == self.id}
+        taggings.each{|tagging| tag.taggings.delete tagging}
+        tag.save_or_destroy
+        tag_words.delete model_tag.word
+        model_tags.delete model_tag
+      end
+    end
+    save
+    tags
+  end
+  
+  def self.included(receiver)
+    receiver.class_eval do
+      key :tag_words, Array, :index => true
+      many :model_tags
+      
+      ensure_index 'model_tags.word'
+      ensure_index 'model_tags.tagging_count'
+    end
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+    
+    Tag.register_taggable_type receiver
+  end
+  
+private
+  def destroy_if_empty(tag)
+    if tag.user_ids.empty?
+      tag_words.delete(tag.word)
+      model_tags.delete tag
+    end
+  end
+
+end
+
+%w{ models observers }.each do |dir|
+  path = File.join(File.dirname(__FILE__), 'app', dir)
+  $LOAD_PATH << path
+  ActiveSupport::Dependencies.load_paths << path
+  ActiveSupport::Dependencies.load_once_paths.delete(path)
+end
+

data/lib/app/models/model_tag.rb

@@ -0,0 +1,84 @@
+class ModelTag
+  include MongoMapper::EmbeddedDocument
+  
+  key :word,            String, :required => true
+  key :tagging_count,   Integer
+  key :user_ids,        Array
+  
+  def users
+    UserProxy.new(self)
+  end
+  
+  belongs_to :tag
+  
+  before_save :set_tagging_count
+  
+  def save_or_destroy
+    user_ids.empty? ? destroy : save
+  end
+  
+private
+  def set_tagging_count
+    self.tagging_count = user_ids.size
+  end
+  
+  class UserProxy
+    attr_accessor :model_tag
+    
+    def initialize(model_tag)
+      @model_tag = model_tag
+    end
+    
+    def to_a
+      fetch_all.to_a
+    end
+    
+    def count
+      model_tag.user_ids.size
+    end
+    
+    def all(opts = {})
+      fetch_all
+    end
+    
+    def each(&block)
+      fetch_all.each {|user| yield user}
+    end
+    
+    def find(id)
+      return nil unless model_tag.user_ids.include?(id)
+      User.find(id)
+    end
+    
+    def first(opts = {})
+      return @first ||= User.find(model_tag.user_ids.first) if opts.empty?
+      User.first(opts.merge(:_id.in => model_tag.user_ids))
+    end
+    
+    def last(opts = {})
+      return @last ||= User.find(model_tag.user_ids.last) if opts.empty?
+      User.last(opts.merge(:_id.in => model_tag.user_ids))
+    end
+    
+    alias :size :count
+    
+    def << (user)
+      model_tag.user_ids << user.id
+      model_tag.send(:set_tagging_count)
+    end
+    
+    def delete(user)
+      model_tag.user_ids.delete user.id
+      model_tag.send(:set_tagging_count)
+    end
+    
+    def inspect
+      all.inspect
+    end
+    
+  private
+    def fetch_all
+      @fetch ||= User.find(model_tag.user_ids)
+    end
+  end
+end

data/lib/app/models/tag.rb

@@ -0,0 +1,107 @@
+class Tag
+  include MongoMapper::Document
+  key :word,            String,   :required => true, :index => true
+  key :taggings_count,   Integer, :index => true
+  
+  many :taggings do
+    def << (tagging)
+      super << tagging
+      tagging._parent_document.send(:increment_counts, tagging)
+    end
+    
+    def delete(tagging)
+      target.delete tagging
+      tagging._parent_document.send(:decrement_counts, tagging)
+    end
+  end
+  
+  ensure_index 'taggings.user_id'
+  ensure_index 'taggings.taggable_type'
+  ensure_index 'taggings.taggable_id'
+  
+  before_save :set_tagging_counts
+  
+  def self.register_taggable_type(type)
+    key taggings_count_key_for(type), Integer, :index => true
+  end
+    
+  # == Various Class Methods
+  
+  # takes a string and produces an array of words from the db that are 'like' this one
+  # great for those oh-so-fancy autocomplete/suggestion text fields
+  def self.like(string, klass = nil)
+    opts = {:word => /^#{string}/}
+    opts['taggings.taggable_type'] = klass.to_s if klass
+    all(opts)
+  end
+  
+  def self.all_for_class(klass, opts = {})
+    all(opts.merge('taggings.taggable_type' => klass.to_s))
+  end
+  
+  def self.most_tagged(klass = nil, opts = {})
+    order = klass ?  "#{taggings_count_key_for(klass)} desc" : 'taggings_count desc'
+    lo = opts.merge(:order => order)
+    lo['taggings.taggable_type'] = klass.to_s if klass
+    all(lo)
+  end
+  
+  def self.top_25(klass = nil)
+    most_tagged(klass, :limit => 25)
+  end
+  
+  def count_for(klass = nil)
+    klass ? send(taggings_count_key_for(klass)) : taggings_count
+  end
+  
+  #Called when removing taggings.  If no taggings left, destroy, otherwise save
+  def save_or_destroy
+    taggings.empty? ? destroy : save
+  end
+  
+private
+  def set_tagging_counts
+    self.taggings_count = self.taggings.size
+    
+    count_hash = self.taggings.inject({}) do |hash, tagging|
+      key = taggings_count_key_for(tagging.taggable_type)
+      hash[key] ||= 0
+      hash[key] += 1
+      hash
+    end
+    count_hash.each{|key, count| self.send("#{key}=", count)}
+  end
+
+  def increment_counts(tagging)
+    safe_increment_count(:taggings_count)
+    safe_increment_count(taggings_count_key_for(tagging.taggable_type))
+  end
+  
+  def decrement_counts(tagging)
+    safe_decrement_count(:taggings_count)
+    safe_decrement_count(taggings_count_key_for(tagging.taggable_type))
+  end
+  
+  def taggings_count_key_for(type)
+    Tag.taggings_count_key_for(type)
+  end
+  
+  def safe_increment_count(key)
+    val = self.send(key) || 0
+    self.send("#{key}=", val + 1)
+  end
+  
+  def safe_decrement_count(key)
+    self.send("#{key}=", self.send("#{key}") - 1) if self.send("#{key}")
+  end
+  
+  def self.taggings_count_key_for(type)
+    type = type.constantize if type.is_a? String
+    #check for inheritance, get most superclass with include
+    while type.superclass && type.superclass.include?(ActsAsMongoTaggable)
+      type = type.superclass
+    end
+    type = type.name
+    :"#{type.underscore}_taggings_count"
+  end
+end

data/lib/app/models/tagging.rb

@@ -0,0 +1,6 @@
+class Tagging
+  include MongoMapper::EmbeddedDocument
+  
+  belongs_to :user #, :required => true, :index => true
+  belongs_to :taggable, :polymorphic => true
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/acts_as_mongo_taggable.rb'

data/test/acts_as_mongo_taggable_test.rb

@@ -0,0 +1,205 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class ActsAsMongoTaggableTest < ActiveSupport::TestCase
+  
+  def create_user(name)
+    u = User.create({:name => name})
+    puts u.errors unless u.valid?
+    u
+  end
+  
+  def load_multiple_taggers
+    @m_tagger_1 = create_user "m_tagger_1"
+    @m_tagger_2 = create_user "m_tagger_2"
+    @m_tagger_3 = create_user "m_tagger_3"
+  end
+  
+  def multi_tag(obj)
+    load_multiple_taggers
+    obj.tag('frankenstein', @m_tagger_1)
+    obj.tag('frankenstein', @m_tagger_2)
+    obj.tag('vampires', @m_tagger_1)
+    obj.tag('werewolves', @m_tagger_1)
+    obj.tag('werewolves', @m_tagger_2)
+    obj.tag('werewolves', @m_tagger_3)
+  end  
+    
+  def setup
+    @owner = create_user 'owner'
+    @tagger = create_user 'tagger'
+    @widget = @owner.widgets.create({:name => "Test Widget"})
+  end
+  
+  test "widget tagged with the same word multiple times should not have dupes in tag_words" do
+    multi_tag(@widget)
+    assert_equal 3, @widget.tag_words.size
+    @widget.delete_tags_by_user(@m_tagger_1)
+    assert_equal 2, @widget.tag_words.size
+  end
+  
+  test "ensure we can actually tag two different object types without collisions" do
+    dongle_owner = create_user "dongle_owner"
+    dongle = dongle_owner.dongles.create({:name => "Test Dongle"})
+    # tag the widget
+    multi_tag(@widget)
+    assert_equal 3, @widget.tags.size
+    assert_equal 0, dongle.tags.size
+    # tag the dongle
+    multi_tag(dongle)
+    assert_equal 3, @widget.tags.size
+    assert_equal 3, dongle.tags.size
+    # delete from the widget
+    @widget.delete_all_tags
+    assert_equal 0, @widget.tags.size
+    assert_equal 3, dongle.tags.size
+    # delete from the dongle
+    dongle.delete_all_tags
+    assert_equal 0, @widget.tags.size
+    assert_equal 0, dongle.tags.size
+  end
+  
+  test "search and find all widgets containing a specified tag" do
+    num_found = Widget.all_with_tag('vampires').size
+    assert_equal 0, num_found
+    @widget.tag("vampires", @tagger)
+    num_found = Widget.all_with_tag('vampires').size
+    assert_equal 1, num_found
+    dongle_owner = create_user "dongle_owner"
+    dongle = dongle_owner.dongles.create({:name => "Test Dongle"})
+    multi_tag(dongle)
+    num_found = Widget.all_with_tag('vampires').size
+    # should only be 1 because we're only searching on Widgets!
+    assert_equal 1, num_found
+  end
+  
+  test "find first widget that matches specified tag" do
+    @widget.tag("vampires", @tagger)
+    dongle_owner = create_user "dongle_owner"
+    dongle = dongle_owner.dongles.create({:name => "Test Dongle"})
+    # should only be 1 because we're only searching on Widgets!
+    assert_equal 1, Widget.all_with_tag('vampires').size
+    assert_equal @widget, Widget.first_with_tag('vampires')
+  end
+  
+  test "all_with_tag and first_with_tag are case-insensitive" do
+    @widget.tag("VaMpiReS", @tagger)
+    @widget.tag("VAMPIRES", @tagger)
+    assert_equal @widget, Widget.first_with_tag("VampireS")
+    assert_equal 1, Widget.all_with_tag("VampireS").size
+  end
+  
+  test "case-sensitive mode" do
+    @widget.tag("VaMpiReS", @tagger, {:case_sensitive => true})
+    assert_equal 0, Widget.all_with_tag("vampires").size
+    assert_equal 0, Widget.all_with_tag("VaMpiReS").size
+    assert_equal 0, Widget.all_with_tag("vampires", {:case_sensitive => true}).size
+    assert_equal 1, Widget.all_with_tag("VaMpiReS", {:case_sensitive => true}).size
+  end
+  
+  test "we get an empty array if we ask for all tags with counts and there are none" do
+    assert_equal 0, Tag.count
+    assert_equal [], Widget.all_tags_with_counts
+  end
+  
+  test "we can build an array of tags and counts across an entire tagged object space" do
+    multi_tag(@widget)
+    dongle_owner = create_user "dongle_owner"
+    dongle = dongle_owner.dongles.create({:name => "Test Dongle"})
+    dongle.tag("werewolves", @m_tagger_1)
+    dongle.tag("werewolves", @m_tagger_2)
+    assert_equal [["werewolves", 3], ["frankenstein", 2], ["vampires", 1]], Widget.all_tags_with_counts
+    assert_equal [["werewolves", 2]], Dongle.all_tags_with_counts
+  end
+  
+  test "most_tagged_with returns the proper widget" do
+    widget_one = @owner.widgets.create({:name => "Test Widget One"})
+    widget_two = @owner.widgets.create({:name => "Test Widget Two"})
+    widget_three = @owner.widgets.create({:name => "Test Widget Three"})
+    load_multiple_taggers
+    #widget one -- worst
+    widget_one.tag("werewolves", @m_tagger_1)
+    #widget two -- best
+    multi_tag(widget_two)
+    #widget three -- middle child
+    widget_three.tag("werewolves", @m_tagger_1)
+    widget_three.tag("werewolves", @m_tagger_2)
+    # now, did it work?
+    assert_equal widget_two, Widget.most_tagged_with('werewolves')
+  end
+    
+  test "tag is created when project tagged" do
+    assert_equal 0, @widget.tags.size
+    @widget.tag("vampires", @tagger)
+    assert_equal 1, @widget.tags.size
+  end
+  
+  test "tagged_by_user? returns true when this object tagged by user" do
+    assert ! @widget.tagged_by_user?(@tagger)
+    @widget.tag("vampires", @tagger)
+    assert @widget.tagged_by_user?(@tagger)
+  end
+  
+  test "tagged_by_user? returns false when this object not tagged but some other object is" do
+    dongle_owner = create_user "dongle_owner"
+    dongle = dongle_owner.dongles.create({:name => "Test Dongle"})
+    dongle.tag("vampires", @tagger)
+    assert ! @widget.tagged_by_user?(@tagger)    
+  end
+  
+  test "tag object can be retrieved after project tagged" do
+    assert_equal 0, @widget.tags.size
+    @widget.tag("werewolves", @tagger)
+    assert_equal "werewolves", @widget.tags.first
+  end
+
+  test "widget returns correct array with multiple tags with 1 count each" do
+    %w(vampires werewolves frankenstein).each {|word| @widget.tag(word, @tagger)}
+    assert_equal 3, @widget.tags.size
+    ["vampires", "werewolves", "frankenstein"].each { |t| assert @widget.tags.include?(t) }
+  end
+
+  test "widget returns correct array with multiple tags with varying counts" do
+    multi_tag(@widget)
+    assert_equal 3, @widget.tags.size
+    assert_equal ["werewolves", "frankenstein", "vampires"], @widget.tags
+  end
+  
+  test "tags_with_counts returns the right tags and counts" do
+    expected = [["werewolves", 3], ["frankenstein", 2], ["vampires", 1]]
+    multi_tag(@widget)
+    assert_equal expected, @widget.tags_with_counts
+  end
+  
+  test "same user cannot multi-tag with same word using tag!()" do
+    assert_raise StandardError do
+      3.times { @widget.tag!('frankenstein', @tagger) }
+    end
+  end
+  
+  test "delete only tags by certain users" do
+    multi_tag(@widget)
+    assert_equal 3, @widget.tags.size
+    assert_equal 6, @widget.model_tags.inject(0){|r, tag| r + tag.tagging_count}
+
+    @widget.delete_tags_by_user(@m_tagger_1)
+    assert_equal 2, @widget.tags.size
+    assert_equal 3, @widget.model_tags.inject(0){|r, tag| r + tag.tagging_count}
+    
+    @widget.delete_tags_by_user(@m_tagger_2)
+    assert_equal 1, @widget.tags.size   
+    assert_equal 1, @widget.model_tags.inject(0){|r, tag| r + tag.tagging_count}
+  end
+  
+  test "silently ignore multi-tag by single user with same word using tag()" do
+    3.times { @widget.tag('frankenstein', @tagger) }
+    assert_equal 1, @widget.tags.size
+  end
+  
+  test "widget with multiple tags can be cleared" do
+    %w(vampires werewolves frankenstein).each {|word| @widget.tag(word, @tagger)}
+    assert_equal 3, @widget.tags.size
+    @widget.delete_all_tags
+    assert_equal 0, @widget.tags.size
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/test_case'
+require 'test/unit'
+
+ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/../../../..'
+env_rb = File.expand_path(File.join(ENV['RAILS_ROOT'], 'config/environment.rb'))
+
+if File.exists? env_rb
+  require env_rb
+else
+  require 'mongo_mapper'
+  require File.dirname(__FILE__) + '/../lib/acts_as_mongo_taggable'
+  config = {'test' => {'database' => 'aamt-test'}}
+  MongoMapper.setup(config, 'test')
+end
+
+class ActiveSupport::TestCase
+  # Drop all columns after each test case.
+  def teardown
+    MongoMapper.database.collections.each do |coll|
+      coll.drop  
+    end
+  end
+ 
+  # Make sure that each test case has a teardown
+  # method to clear the db after each test.
+  def inherited(base)
+    base.define_method teardown do 
+      super
+    end
+  end
+end
+
+# kinda weird, but we have to do this so we can ignore the app's User class and use our own for testing
+Object.send(:remove_const, :User) if Object.const_defined?(:User)
+
+class User
+  include MongoMapper::Document
+  key :name, String
+  has_many :widgets
+  has_many :dongles
+end
+
+class Widget
+  include MongoMapper::Document  
+  include ActsAsMongoTaggable 
+
+  belongs_to :user
+  
+  key :user_id, ObjectId
+  key :name, String
+end
+
+class Dongle
+  include MongoMapper::Document  
+  include ActsAsMongoTaggable 
+
+  belongs_to :user
+  
+  key :user_id, ObjectId
+  key :name, String
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: yoomee-acts_as_mongo_taggable
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 2
+  version: 0.2.2
+platform: ruby
+authors: 
+- Ian Mooney
+- Matt Atkins
+- Matt E. Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-17 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo_mapper
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 7
+        - 0
+        version: 0.7.0
+  type: :runtime
+  version_requirements: *id001
+description: A ruby gem for acts_as_taggable to mongo
+email: matt@yoomee.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- MIT-LICENSE
+- Rakefile
+- lib/acts_as_mongo_taggable.rb
+- lib/app/models/model_tag.rb
+- lib/app/models/tag.rb
+- lib/app/models/tagging.rb
+- rails/init.rb
+- README.markdown
+- test/acts_as_mongo_taggable_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/yoomee/acts_as_mongo_taggable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A ruby gem for acts_as_taggable to mongo
+test_files: 
+- test/acts_as_mongo_taggable_test.rb
+- test/test_helper.rb