genki-dm-is-taggable 0.1

data/History.txt

@@ -0,0 +1 @@
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Aaron Qian, Maxime Guilbot at Ekohe
+
+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/Manifest.txt

@@ -0,0 +1,25 @@
+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

data/README.textile

@@ -0,0 +1,185 @@
+h1. dm-is-taggable
+
+dm-is-taggable is a tagging system built for datamapper. It has supports for multiple tagger types and taggable types.
+Each tagger can tag different taggable objects.
+
+
+h2. Installation
+
+h3. Download the plugin
+
+In your console:
+<pre><code>
+git clone git://github.com/aq1018/dm-is-taggable.git
+</code></pre>
+
+h3. Install the gem
+
+In your console:
+<pre><code>
+cd dm-is-taggable
+sudo rake install
+</code></pre>
+
+h3. Include it Merb
+
+In merb init.rb:
+
+<pre><code>
+dependency "dm-is-taggable"
+</code></pre>
+
+
+h2. Using dm-is-taggable in your code
+
+h3. Define taggers
+
+<pre><code>
+  class User
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+    is :tagger, :on => ["Article", "Picture"]
+  end
+
+  class Bot
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+    is :tagger, :on => ["Article", "Picture"]
+  end
+</code></pre>
+
+h3. Define taggables
+
+<pre><code>
+  class Article
+    include DataMapper::Resource
+    property :id, Serial
+    is :taggable, :by => ["User", "Bot"]
+  end
+
+  class Picture
+    include DataMapper::Resource
+    property :id, Serial
+    is :taggable, :by => ["User", "Bot"]
+  end
+</code></pre>
+
+h3. Create tags
+
+<pre><code>
+  
+  @picture = Picture.first
+  @scott = User.first
+  
+  # You can tag like this
+  @picture.tag(:with => "shanghai, bar, beer", :by => @scott)
+  
+  # or like this
+  # Note: this doesn't remove the previous tags
+  Tag.as(@scott) do
+    @picture.tag(:with => "cool, tag1, tag2")
+  end
+  
+  # or like this
+  # Note, this removes all previous tags
+  Tag.as(@scott) do
+    @picture.taglist("cool, tag1, tag2")
+  end
+</code></pre>
+
+h3. Retrieve objects with tags
+
+<pre><code>
+  
+  # find pictures tagged with tag1 and tag2
+  Picture.find(:with => "tag1, tag2")
+  
+  # find pictures tagged with tag1 or tag2
+  Picture.find(:with => "tag1, tag2", :match => :any)
+  
+  # find pictures tagged with tag1 or tag2, tagged by @user1
+  Picture.find(:with => "tag1, tag2", :match => :any, :by => @user1)
+  
+  # find pictures tagged with tag1 or tag2, tagged by all users
+  Picture.find(:with => "tag1, tag2", :match => :any, :by => User)
+  
+  # or you can do scoped way
+  
+  # find pictures tagged with tag1 or tag2, tagged by all users
+  Tag.as(User) do
+    Picture.find(:with => "tag1, tag2", :match => :any)
+  end
+  
+  # find pictures tagged with tag1 or tag2, tagged by @user1
+  Tag.as(@user1) do
+    Picture.find(:with => "tag1, tag2", :match => :any)
+  end
+  
+    
+  # You can tag like this
+  @picture.tag(:with => "shanghai, bar, beer", :by => @scott)
+  
+  # or like this
+  # Note: this doesn't remove the previous tags
+  Tag.as(@scott) do
+    @picture.tag(:with => "cool, tag1, tag2")
+  end
+  
+  # or like this
+  # Note, this removes all previous tags
+  Tag.as(@scott) do
+    @picture.taglist("cool, tag1, tag2")
+  end
+</code></pre>
+
+h3. Retrieve tags with objects
+
+<pre><code>
+  
+  @picture1 = Picture.first
+  
+  # get all tags associated with @picture2 as a string
+  @picture1.taglist
+  
+  # or as tag objects
+  @picture1.tags
+  
+  # tags tagged by users
+  @picture1.tags_by_users
+  
+  # find tags by all users
+  Tag.by(User)
+
+  # find tags by a user
+  Tag.by(@user)
+
+  # find tags on all pictures
+  Tag.on(Picture)
+  
+  # find tags on a picture
+  Tag.on(@picture1)
+  
+  # find tags by a user, on all pictures
+  Tag.by(@user).on(Pictures)
+  
+  # find tags by all users on a picture
+  Tag.by(User).on(@picture)
+  
+  # find tags by a user on a picture
+  Tag.by(@user).on(@picture)
+  
+</code></pre>
+
+h3. Counting tags
+
+<pre><code>
+  
+  # Count how many articles are tagged by @user1
+  Tag.tagged_count(:by => @user1, :on => Article)
+  
+  # Count how many articles are tagged by @user1 with "tag1"
+  Tag.tagged_count(:by => @user1, :on => Article, :with => "tag1")
+    
+</code></pre>

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'spec'
+require 'spec/rake/spectask'
+require 'pathname'
+
+ROOT = Pathname(__FILE__).dirname.expand_path
+require ROOT + 'lib/dm-is-taggable/is/version'
+
+AUTHOR = "Aaron Qian, Maxime Guilbot"
+EMAIL  = "team [a] ekohe [d] com"
+GEM_NAME = "dm-is-taggable"
+GEM_VERSION = DataMapper::Is::Taggable::VERSION
+GEM_DEPENDENCY_VERSION = DataMapper::Is::Taggable::DEPENDENCY_VERSION
+GEM_DEPENDENCIES = [["dm-core", GEM_DEPENDENCY_VERSION], ["dm-aggregates", GEM_DEPENDENCY_VERSION]]
+GEM_CLEAN = ["log", "pkg"]
+GEM_EXTRAS = { :has_rdoc => false, :extra_rdoc_files => %w[ README.textile LICENSE TODO ] }
+
+PROJECT_NAME = "dm-is-taggable"
+PROJECT_URL  = "http://github.com/aq1018/dm-is-taggable"
+PROJECT_DESCRIPTION = PROJECT_SUMMARY = "Tagging implementation for DataMapper"
+
+require 'tasks/hoe'
+
+task :default => [ :spec ]
+
+WIN32 = (RUBY_PLATFORM =~ /win32|mingw|cygwin/) rescue nil
+SUDO  = WIN32 ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+desc "Install #{GEM_NAME} #{GEM_VERSION}"
+task :install => [ :package ] do
+  sh "#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources", :verbose => false
+end
+
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION} (default ruby)"
+task :uninstall => [ :clobber ] do
+  sh "#{SUDO} gem uninstall #{GEM_NAME} -v#{GEM_VERSION} -I -x", :verbose => false
+end
+
+desc 'Run specifications'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.spec_files = Pathname.glob(Pathname.new(__FILE__).dirname + 'spec/**/*_spec.rb')
+
+  begin
+    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov_opts << '--exclude' << 'spec'
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  rescue Exception
+    # rcov not installed
+  end
+end

data/TODO

@@ -0,0 +1,2 @@
+TODO
+====

data/lib/dm-is-taggable.rb

@@ -0,0 +1,31 @@
+# Needed to import datamapper and other gems
+require 'rubygems'
+require 'pathname'
+
+# Add all external dependencies for the plugin here
+gem 'dm-core', '=0.9.6'
+gem 'dm-aggregates', '>=0.9.6'
+require 'dm-core'
+require 'dm-aggregates'
+
+# Require plugin-files
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-taggable' / 'tag_list.rb'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-taggable' / 'aggregate_patch.rb'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-taggable' / 'is' / 'shared.rb'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-taggable' / 'is' / 'taggable.rb'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-taggable' / 'is' / 'tag.rb'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-taggable' / 'is' / 'tagging.rb'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-taggable' / 'is' / 'tagger.rb'
+
+# Include the plugin in Resource
+module DataMapper
+  module Resource
+    module ClassMethods
+      include DataMapper::Is::Taggable
+    end # module ClassMethods
+  end # module Resource
+end # module DataMapper
+
+# Require the Tag and Tagging Resources
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-taggable' / 'tag.rb'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-taggable' / 'tagging.rb'

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

@@ -0,0 +1,47 @@
+# we need this unless someone adds the "count(distinct id)" support in dm-aggegrates
+module DataMapper
+  module Adapters
+    class DataObjectsAdapter
+      module SQL
+        private
+         def fields_statement(query)
+          qualify = query.links.any?
+          query.fields.map { |p| property_to_column_name(query.repository, p, qualify, query.unique?) } * ', '
+        end
+ 
+         def property_to_column_name(repository, property, qualify, unique=false)
+          case property
+            when Query::Operator
+              aggregate_field_statement(repository, property.operator, property.target, qualify, unique)
+            when Property
+              original_property_to_column_name(repository, property, qualify)
+            when Query::Path
+             original_property_to_column_name(repository, property, qualify)
+            else
+              raise ArgumentError, "+property+ must be a DataMapper::Query::Operator or a DataMapper::Property, but was a #{property.class} (#{property.inspect})"
+          end
+        end
+ 
+        def aggregate_field_statement(repository, aggregate_function, property, qualify, unique=false)
+          column_name = if aggregate_function == :count && property == :all
+            '*'
+          else
+            unique ? "distinct #{property_to_column_name(repository, property, qualify)}" :
+              property_to_column_name(repository, property, qualify)
+          end
+ 
+          function_name = case aggregate_function
+            when :count then 'COUNT'
+            when :min then 'MIN'
+            when :max then 'MAX'
+            when :avg then 'AVG'
+            when :sum then 'SUM'
+            else raise "Invalid aggregate function: #{aggregate_function.inspect}"
+          end
+ 
+          "#{function_name}(#{column_name})"
+        end
+      end # module SQL
+    end # class DataObjectsAdapter
+  end # module Adapters
+end # module DataMapper

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

@@ -0,0 +1,111 @@
+module DataMapper
+  module Is
+    module Taggable
+      module SharedClassMethods
+        
+        def extract_class_object(obj)
+          return [] if obj.nil?
+          if obj.is_a?(Class)
+            [obj, nil]            
+          else
+            [obj.class, obj]
+          end
+        end
+        
+        def by(tagger_class_or_obj)
+          tagger_class, tagger_obj = extract_tagger_class_object(tagger_class_or_obj)
+          query = {:unique => true}
+          query.merge!(Tag.taggings.tagger_type => tagger_class.to_s) if tagger_class
+          query.merge!(Tag.taggings.tagger_id => tagger_obj.id) if tagger_obj
+          all(query)
+        end
+
+        def on(taggable_class_or_obj)
+          taggable_class, taggable_obj = extract_taggable_class_object(taggable_class_or_obj)
+          query = {:unique => true}
+          query.merge!(Tag.taggings.taggable_type => taggable_class.to_s) if taggable_class
+          query.merge!(Tag.taggings.taggable_id => taggable_obj.id) if taggable_obj
+          all(query)
+        end
+        
+       def extract_options(options)
+         if options.is_a?(Array) || options.is_a?(String)
+           options = {:with => TagList.from(options)}
+         end
+         options = options.dup
+         
+         tagger = options.delete(:by)
+         tagger ||= Tag.tagger
+         taggable = options.delete(:on)
+         tags = TagList.from(options.delete(:with))
+         return [tagger, taggable, tags, options]
+       end
+        
+       def extract_tagger_class_object(obj)
+         obj = Extlib::Inflection.constantize(obj.to_s.camel_case.singular) if  obj && (obj.is_a?(String) || obj.is_a?(Symbol))
+         return [] if obj.nil?
+         
+         if obj.tagger?
+           extract_class_object(obj)
+         else
+            raise Exception.new("#{obj} is not a Tagger class or object!")
+         end
+       end
+        
+       def extract_taggable_class_object(obj)
+         obj = Extlib::Inflection.constantize(obj.to_s.camel_case.singular) if  obj && (obj.is_a?(String) || obj.is_a?(Symbol))
+         return [] if obj.nil?
+         
+         if obj.taggable?
+           extract_class_object(obj)
+         else
+           raise Exception.new("#{obj} is not a Taggable class or object!")
+         end
+       end
+                
+        def create_taggings(tagger, taggable, tags=nil)
+          return if tags.nil? || tags.empty?
+          
+          unless tagger.nil? || (tagger.respond_to?(:tagger?) && tagger.tagger? && !tagger.is_a?(Class))
+            raise Exception.new("#{tagger} is not a tagger datamapper resource object!")
+          end
+          
+          unless taggable.respond_to?(:taggable?) && taggable.taggable? && !taggable.is_a?(Class)
+            raise Exception.new("#{taggable} is not a taggable datamapper resource object!")
+          end
+          
+          raise Exception.new("#{tagger.class} cannot Tag #{taggable.class}") unless tagger.nil? || tagger.can_tag_on?(taggable)
+                          
+          TagList.from(tags).each do |tag|
+            tag_obj = Tag.fetch(tag)
+            
+            # build tagging (tagger could be anonymous)
+            tagging_hash = {:tag_id => tag_obj.id, :taggable_id => taggable.id, :taggable_type => taggable.class.to_s}
+            tagging_hash.merge!(:tagger_id => tagger.id, :tagger_type => tagger.class.to_s) if tagger
+
+            # see if we already have this tagging
+            tagging_obj = Tagging.first(tagging_hash)
+            
+            # if we have the tagging already, just skip this one...
+            next if tagging_obj
+            
+            # tagging is not in db, let's create one            
+            Tagging.create(tagging_hash)
+          end # end of each
+        end
+      end
+      
+      module SharedInstanceMethods
+        def  extract_tagger_class_object(tagger_class_or_object)
+          self.class.extract_tagger_class_object(tagger_class_or_object)
+        end
+        def  extract_taggable_class_object(taggable_class_or_object)
+          self.class.extract_taggable_class_object(taggable_class_or_object)
+        end
+        def extract_options(options)
+          self.class.extract_options(options)
+        end
+      end
+    end
+  end
+end