genki-dm-is-taggable 0.1

data/lib/dm-is-taggable/tagging.rb

@@ -0,0 +1,4 @@
+class Tagging
+  include DataMapper::Resource
+  is :tagging     
+end

data/spec/data/article.rb

@@ -0,0 +1,5 @@
+class Article
+  include DataMapper::Resource
+  property :id, Serial
+  is :taggable, :by => ["User", "Bot"]
+end

data/spec/data/bot.rb

@@ -0,0 +1,6 @@
+class Bot
+  include DataMapper::Resource
+  property :id, Serial
+  property :name, String
+  is :tagger, :on => ["Article", "Picture"]
+end

data/spec/data/picture.rb

@@ -0,0 +1,5 @@
+class Picture
+  include DataMapper::Resource
+  property :id, Serial
+  is :taggable, :by => ["User", "Bot"]
+end

data/spec/data/user.rb

@@ -0,0 +1,6 @@
+class User
+  include DataMapper::Resource
+  property :id, Serial
+  property :name, String
+  is :tagger, :on => ["Article", "Picture"]
+end

data/spec/integration/taggable_spec.rb

@@ -0,0 +1,289 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+#DataObjects::Sqlite3.logger = DataObjects::Logger.new(STDOUT, 0)
+DataMapper.auto_migrate!
+
+if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
+  describe 'DataMapper::Is::Taggable' do
+    before(:all) do
+      @user1 = User.create(:name => "user1")
+      @user2 = User.create(:name => "user2")\
+      
+      @bot1 = Bot.create(:name => "bot1")
+      @bot2 = Bot.create(:name => "bot2")
+      
+      @picture1 = Picture.create
+      @picture1.tag(:by => @user1, :with => "tag1, tag2, tag3")
+      @picture1.tag(:by => @user2, :with => "tag10, tag2, tag3")
+
+      @picture2 = Picture.create
+      @user2.tag(:on=>@picture2,  :with => ["tag1", "tag4", "tag5"])
+      
+      @picture1.tag(:by => @bot1, :with => ["tag1, tag3, tag_by_bot"])
+
+      @article = Article.create
+      @article.tag(:by =>@user1, :with => ["tag1", "tag4", "tag5"])
+    end
+    
+    it "should be able to tag with taglist" do
+      picture = Picture.new
+      picture.taglist = "tag1, tag2, tag3"
+      picture.save.should == true
+      picture.tags.count.should == 3
+      picture.taglist.should == "tag1, tag2, tag3"
+      picture.destroy      
+    end
+    
+    it "should be able to tag with taglist with user scope" do
+      picture = Picture.new
+      user = User.create(:name => "me")
+      
+      Tag.as(user) do
+        picture.taglist = "tag1, tag2, tag3"
+        picture.save.should == true
+      end      
+      picture.tags.count.should == 3
+      Tag.by(user).on(picture).sort.should == [Tag.get("tag1"), Tag.get("tag2"), Tag.get("tag3")].sort
+      picture.destroy
+    end
+
+    it "should be able to update tags with taglist" do
+      picture = Picture.new
+      picture.taglist = "tag1, tag2, tag3"
+      picture.save
+      
+      picture.taglist = "tag1, tag3, tag4, tagme"  
+      picture.tags.count.should == 4
+      picture.taglist.should == "tag1, tag3, tag4, tagme"
+      
+      picture.destroy      
+    end
+    
+    it "should setup to tagger_classes and taggable_classes accessors for taggables and taggers" do
+      Picture.respond_to?(:tagger_classes).should be_true
+      User.respond_to?(:taggable_classes).should be_true
+    end
+
+    it "should be able to tag by taggers" do
+      picture = Picture.new
+      user = User.new(:name => "me")
+      user.save.should == true
+      picture.save.should == true
+      
+      picture.tag(:by => user, :with =>["tagme", "tagtag", "tagtagtag"])
+      user.tag(:on =>picture, :with => ["tag3", "tag4", "tag5"])
+      
+      picture.taggings.count.should == 6
+      picture.tags.count.should == 6
+      
+      user.destroy
+      picture.destroy
+    end
+    
+    it "should be able to tag anonymously" do
+      picture = Picture.new
+      picture.save.should == true
+      
+      picture.tag(:with => ["tagme", "tagtag", "tagtagtag"])
+      picture.tags.count.should == 3
+      
+      picture.tags.include?(Tag.get("tagme")).should be_true
+      picture.tags.include?(Tag.get("tagtag")).should be_true
+      picture.tags.include?(Tag.get("tagtagtag")).should be_true
+      
+      picture.taggings.each do |tag|
+        tag.tagger_type.should be_nil
+        tag.tagger_id.should be_nil
+      end
+      
+      picture.destroy
+    end
+    
+    it "should be able to retrieve Picture by with_any_tags" do
+      Picture.find( :match => :any ,:with => ["tag2", "tag5"]).size.should == 2
+      Picture.find( :match => :any ,:with => ["tag2", "tag5"]).include?(@picture1).should be_true
+      Picture.find( :match => :any ,:with => ["tag2", "tag5"]).include?(@picture2).should be_true
+
+      Picture.find( :match => :any ,:by => User, :with => ["tag2", "tag5"]).size.should == 2
+      Picture.find( :match => :any ,:by => User, :with => ["tag2", "tag5"]).include?(@picture1).should be_true
+      Picture.find( :match => :any ,:by => User, :with => [ "tag2", "tag5"]).include?(@picture2).should be_true
+      
+      Picture.find( :match => :any ,:by => Bot, :with => ["tag_by_bot", "tag5"]).size.should == 1
+      Picture.find( :match => :any ,:by => Bot, :with => ["tag_by_bot", "tag5"]).include?(@picture1).should be_true
+    end
+    
+    it "should be able to retrieve Picture by find" do
+      Picture.find(:with =>"tag1").size.should == 2
+      Picture.find(:with =>"tag1").include?(@picture1).should be_true
+      Picture.find(:with =>"tag1").include?(@picture2).should be_true
+      
+      Picture.find(:by =>User, :with =>"tag1").size.should == 2
+      Picture.find(:by =>User,:with => "tag1").include?(@picture1).should be_true
+      Picture.find(:by =>User, :with =>"tag1").include?(@picture2).should be_true
+      
+      Picture.find(:by =>Bot,:with => "tag1").size.should == 1
+      Picture.find(:by =>Bot, :with =>"tag1").include?(@picture1).should be_true
+
+      Picture.find(:with =>"tag2").should == [@picture1]
+      
+      Picture.find(:with =>["tag1", "tag2"]).should == [@picture1]
+      Picture.find(:with =>"non existing tag").should == []
+    end
+    
+    
+    it "should be able to retrieve all tags" do
+      # ALL taggers
+      all_tags = @picture1.tags
+      all_tags.size.should == 5
+      all_tags.include?(Tag.get("tag1")).should be_true
+      all_tags.include?(Tag.get("tag2")).should be_true
+      all_tags.include?(Tag.get("tag3")).should be_true
+      all_tags.include?(Tag.get("tag_by_bot")).should be_true
+      all_tags.include?(Tag.get("tag10")).should be_true
+      # Users
+      all_tags = @picture1.tags_by_users
+      all_tags.size.should == 4
+      all_tags.include?(Tag.get("tag1")).should be_true
+      all_tags.include?(Tag.get("tag2")).should be_true
+      all_tags.include?(Tag.get("tag3")).should be_true
+      all_tags.include?(Tag.get("tag10")).should be_true
+      
+      # Bots
+      all_tags = @picture1.tags_by_bots
+      all_tags.size.should == 3
+      all_tags.include?(Tag.get("tag1")).should be_true
+      all_tags.include?(Tag.get("tag3")).should be_true
+      all_tags.include?(Tag.get("tag_by_bot")).should be_true
+     end
+    
+    it "should handle scoped tag creation" do
+      picture = Picture.new
+      user = User.new(:name => "me")
+      user.save.should == true
+      picture.save.should == true
+  
+      Tag.as(user) do
+        picture.tag(:with => "scoped_tag")
+      end
+      Picture.find(:with => "scoped_tag").size.should == 1
+      Picture.find("scoped_tag").include?(picture).should be_true
+      
+      user.destroy
+      picture.destroy      
+    end
+    
+    it "should handle scoped tag retrieval" do
+      Tag.as(Bot) do
+        Picture.find( :match => :any , :with => "tag_by_bot").size.should == 1
+        Picture.find( :match => :any ,:with => "tag_by_bot").include?(@picture1).should be_true
+      end
+
+      Tag.as(User) do
+        Picture.find( :match => :any , :with => "tag_by_bot").should be_empty
+        Picture.find("tag1, tag2, tag3").size.should == 1
+        Picture.find("tag1, tag2, tag3").include?(@picture1).should be_true
+        
+        Picture.find( :match => :any ,:with => "tag1").size.should == 2
+        Picture.find("tag1").include?(@picture1).should be_true
+        Picture.find("tag1").include?(@picture2).should be_true
+      end
+    end
+    
+    it "should be able to retrieve picture tags count" do
+      # This requires a dm-aggration and the patch that enables unique count
+      # Note: @picture1.tags_by_users.size also works, but less optimized. this uses COUNT in sql
+      @picture1.count_tags_by_users.should == 4
+      @picture1.count_tags_by_bots.should == 3
+      @picture1.count_tags.should == 5
+    end
+    
+     it "should be able to retrieve amount of times tag has been used" do
+       # picture1 picture2 article1
+       Tag.get("tag1").tagged_count.should == 3
+       # picture1 picture2 article1
+       Tag.get("tag1").tagged_count(:by => "User").should == 3
+       # picture1
+       Tag.get("tag1").tagged_count(:by => Bot).should == 1
+       # article1 and picture1
+       Tag.get("tag1").tagged_count(:by => @user1).should == 2
+       
+      Tag.get("tag1").tagged_count(:by =>@user1, :on => Picture) == 1
+     end
+     
+     it "should be able to retrieve tags by the specified relation object" do
+       Tag.by(@user1).sort.should == [Tag.get("tag1"), Tag.get("tag2"), Tag.get("tag3"), Tag.get("tag4"), Tag.get("tag5")].sort
+       Tag.by(User).sort.should == [Tag.get("tag1"), Tag.get("tag2"), Tag.get("tag3"), Tag.get("tag4"), Tag.get("tag5"), Tag.get("tag10")].sort
+       Tag.on(@article).sort.should == [Tag.get("tag1"), Tag.get("tag4"), Tag.get("tag5")].sort
+       Tag.on(@picture1).by(@user2).sort.should == [Tag.get("tag2"), Tag.get("tag3"), Tag.get("tag10")].sort
+     end
+          
+     it "should be able to retrieve specified tags by the specified relation object" do
+       Picture.find(:with =>"tag1", :by => @user1).should == [@picture1]
+       Picture.find(:with =>"tag2", :by => @user2).should == [@picture1]
+       Picture.find(:with => ["tag1", "tag2"], :by => @bot1, :match => :any).should == [@picture1]
+     end
+
+    it "should be able to retrieve all tags by the user" do
+       @user1.tags.size.should == 5
+       @user1.tags.include?(Tag.get("tag1")).should be_true
+       @user1.tags.include?(Tag.get("tag2")).should be_true
+       @user1.tags.include?(Tag.get("tag3")).should be_true
+       @user1.tags.include?(Tag.get("tag4")).should be_true
+       @user1.tags.include?(Tag.get("tag5")).should be_true
+     end
+
+    it "should be able to retrieve all objects tagged by the user" do
+       @user1.find_taggables(:with =>["tag1", "tag4"], :match => :any).should == [@article, @picture1]
+       @user1.find_taggables(:with =>["tag1", "tag4"], :match => :all).should == [@article]
+     end
+          
+     it "should be able to retrieve all objects tagged with certain tag" do
+       Tag.find_taggables(:with => ["tag1", "tag4"]).should == [@article, @picture2]
+       Tag.find_taggables(:with => ["tag1", "tag4"], :match => :any).should == [@article, @picture1, @picture2]
+     end
+     
+     it "should be able to retrieve taggable_objects of user with specified tags" do
+       @user2.find_taggables(:with => "tag1").should == [@picture2]
+     end
+     
+     it "should be able to retrieve how many times the user used the tag" do
+       Tag.tagged_count(:by => @user1, :on => @article, :with => "tag1").should == 1
+       Tag.tagged_count(:by => Bot,  :with => "tag1").should == 1
+       Tag.tagged_count(:by => @user1,  :with => "tag1").should == 2
+       Tag.tagged_count(:by => @user1).should == 2
+       Tag.tagged_count(:by => User).should == 3
+       Tag.tagged_count.should == 3
+     end
+     
+     it "should be able to retrieve the most association (in this case user) popular by tags for a certain tag" do
+       # This returns a list of taggers with descending order of tag count
+       Tag.get("tag1").popular_by_tags.should == [@user1, @user2, @bot1] # should return array and calculate this based upon the usage of the tag
+     end
+         
+    it "should be able to retrieve related tags that where used in the same set" do
+      related_tags = Tag.get("tag3").related
+      related_tags.size.should == 2
+      related_tags.include?([2,Tag.get("tag1")]).should be_true
+      related_tags.include?([2,Tag.get("tag2")]).should be_true
+      
+      related_tags = Tag.get("tag1").related
+      related_tags.size.should == 4
+      related_tags.include?([2,Tag.get("tag2")]).should be_true
+      related_tags.include?([3,Tag.get("tag3")]).should be_true
+      related_tags.include?([2,Tag.get("tag4")]).should be_true
+      related_tags.include?([2,Tag.get("tag5")]).should be_true
+    end
+
+    it "should be able to retrieve the times that tags where used in the same set" do
+      # tag1 and tag3 are tagged together 2 times by user1 and bot1
+      
+      # I think you just want to find the counts on related tags...
+      # So what I did was to include the number of counts on Tags#related
+      related_tags = Tag.get("tag3").related
+      related_tags.size.should == 2
+      related_tags.include?([2,Tag.get("tag1")]).should be_true
+      related_tags.include?([2,Tag.get("tag2")]).should be_true
+    end
+  end
+end

data/spec/integration/tagger_similarity_spec.rb

@@ -0,0 +1,40 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
+  describe 'DataMapper::Is::Taggable' do
+    before(:all) do
+      DataMapper.auto_migrate!
+      @user1 = User.create(:name => "user1")
+      @user2 = User.create(:name => "user2")
+      @user3 = User.create(:name => "user3")
+      @user4 = User.create(:name => "user4")
+      
+      @picture1 = Picture.create
+      @picture1.tag(:by => @user1, :with => "tag1, tag2, tag3, tag4")
+      @picture1.tag(:by => @user2, :with => "tag1, tag2, tag3")
+      @picture1.tag(:by => @user4, :with => "weird")
+      
+      @picture2 = Picture.create
+      @user2.tag(:on=>@picture2,  :with => ["tag1", "tag2", "tag4", "tag5", "tag6", "tag7", "tag8"])      
+      @user3.tag(:on => @picture2, :with => ["tag4", "tag5", "tag6", "tag7", "tag8"])
+    end
+
+    it "should be able to retrieve similar users with same kind of tagging behavior sorted on similarity" do
+      # user1 and user2 are sharing tag1, tag2, tag3 and tag4 (4 tags total)
+      # user1 and user3 are sharing tag4 (1 tag total)
+      @user1.all_similar_by_tags.should == [[4, @user2], [1, @user3]]
+      
+      # user2 and user3 are sharing tag4, tag5, tag6, tag7 and tag8 (5 tags total)
+      # user2 and user1 are sharing tag1, tag2, tag3 and tag4 (4 tags total)
+      @user2.all_similar_by_tags.should == [[5, @user3], [4, @user1]]
+
+      # user3 and user2 are sharing tag4, tag5, tag6, tag7 and tag8 (5 tags total)
+      # user3 and user1 are sharing tag4 (1 tag total)
+      @user3.all_similar_by_tags.should == [[5, @user2], [1, @user1]]
+      
+      # check if user4 is alone in the dark
+      @user4.all_similar_by_tags.should be_empty
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--format specdoc
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+gem 'rspec', '>=1.1.3'
+require 'spec'
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'lib/dm-is-taggable'
+
+def load_driver(name, default_uri)
+  return false if ENV['ADAPTER'] != name.to_s
+
+  lib = "do_#{name}"
+
+  begin
+    gem lib, '>=0.9.5'
+    require lib
+    DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
+    DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[name]
+    true
+  rescue Gem::LoadError => e
+    warn "Could not load #{lib}: #{e}"
+    false
+  end
+end
+
+ENV['ADAPTER'] ||= 'mysql'
+
+HAS_SQLITE3  = load_driver(:sqlite3,  'sqlite3::memory:')
+HAS_MYSQL    = load_driver(:mysql,    'mysql://root@localhost/dm_is_taggable_test')
+HAS_POSTGRES = load_driver(:postgres, 'postgres://maxime@localhost/dm_is_taggable_test')
+
+require "dm-types"
+require "dm-aggregates"
+
+require Pathname(__FILE__).dirname.expand_path / 'data' / 'bot'
+require Pathname(__FILE__).dirname.expand_path / 'data' / 'user'
+require Pathname(__FILE__).dirname.expand_path / 'data' / 'picture'
+require Pathname(__FILE__).dirname.expand_path / 'data' / 'article'

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: genki-dm-is-taggable
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Aaron Qian, Maxime Guilbot
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.9.6
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dm-aggregates
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.9.6
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.12.1
+    version: 
+description: Tagging implementation for DataMapper
+email: 
+- team [a] ekohe [d] com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+- LICENSE
+- TODO
+files: 
+- History.txt
+- LICENSE
+- Manifest.txt
+- README.textile
+- Rakefile
+- TODO
+- lib/dm-is-taggable.rb
+- lib/dm-is-taggable/aggregate_patch.rb
+- lib/dm-is-taggable/tag.rb
+- lib/dm-is-taggable/tagging.rb
+- lib/dm-is-taggable/tag_list.rb
+- lib/dm-is-taggable/is/taggable.rb
+- lib/dm-is-taggable/is/version.rb
+- lib/dm-is-taggable/is/shared.rb
+- lib/dm-is-taggable/is/tag.rb
+- lib/dm-is-taggable/is/tagging.rb
+- lib/dm-is-taggable/is/tagger.rb
+- spec/integration/taggable_spec.rb
+- spec/integration/tagger_similarity_spec.rb
+- spec/data/article.rb
+- spec/data/picture.rb
+- spec/data/bot.rb
+- spec/data/user.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/aq1018/dm-is-taggable
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: dm-is-taggable
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Tagging implementation for DataMapper
+test_files: []
+