genki-dm-is-taggable 0.1

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

@@ -0,0 +1,189 @@
+module DataMapper
+  module Is
+    module Taggable
+      
+      def is_tag(options=nil)
+        extend  DataMapper::Is::Taggable::SharedClassMethods
+        include DataMapper::Is::Taggable::SharedInstanceMethods
+        extend  DataMapper::Is::Taggable::TagClassMethods
+        include DataMapper::Is::Taggable::TagInstanceMethods
+        property :id, DataMapper::Types::Serial
+        property :name, String, :length => 255, :unique => true, :nullable => false
+        has n, :taggings
+        @tagger_classes ||= []
+        @taggable_classes ||= []
+      end
+      
+      module TagClassMethods
+        attr_reader :tagger
+        attr_reader :tagger_classes
+        attr_reader :taggable_classes
+        #TODO: check if there is any concurrency problem here
+        # NOT thread safe right now!!
+        # need to make it safer!!
+        def as(tagger_or_tagger_class, &block)
+          self.tagger = tagger_or_tagger_class
+          raise Exception("A block must be provided!") unless block_given?
+          yield
+          self.tagger=nil
+        end
+        
+        def tagged_count(options={})
+          tagger, taggable, tag_list, options = extract_options(options)
+          tagger_class, tagger_obj = extract_tagger_class_object(tagger)
+          taggable_class, taggable_obj = extract_taggable_class_object(taggable)
+          
+          association = Tagging
+          association = association.by(tagger) if tagger
+          association = association.on(taggable) if taggable
+          
+          query = {:unique => true, :fields => [:taggable_type]}
+          query.merge!(Tagging.tag.name => tag_list.to_a) unless tag_list.empty?
+          query.merge!(options)
+          
+          association.aggregate(:taggable_id.count, query).inject(0){|count, i| count + i[1]}
+        end
+        
+        def find_taggables(options)
+          tagger, taggable, tag_list, options = extract_options(options)
+          tagger_class, tagger_obj = extract_tagger_class_object(tagger)
+          taggable_class, taggable_obj = extract_taggable_class_object(taggable)
+                    
+          if taggable_class.nil?
+            rv = Tag.taggable_classes.map{|klass| find_taggables(options.merge(:with => tag_list, :on =>klass, :by => tagger) )}.flatten!
+            rv.uniq!
+            return rv
+          end
+          
+          query = {  taggable_class.tags.tag.name => tag_list.to_a,
+            Tagging.properties[:taggable_type] => taggable_class.to_s,
+            :unique => true
+           }
+           query.merge!(Tagging.properties[:tagger_type] => tagger_class) if tagger_class
+           query.merge!(Tagging.properties[:tagger_id] => tagger_obj.id) if tagger_obj          
+          
+          unless options[:match] == :any
+            conditions = "SELECT COUNT(DISTINCT(tag_id)) FROM taggings INNER JOIN tags ON taggings.tag_id = tags.id WHERE "
+            counter_conditions = [
+              "taggings.taggable_type = '#{taggable_class.to_s}'",
+              "taggings.taggable_id = #{taggable_class.storage_name}.id",
+              "tags.name IN ?"
+              ]
+            counter_conditions << "taggings.tagger_type = '#{tagger_class.to_s}'" if tagger_class
+            counter_conditions << "taggings.tagger_id = #{tagger_obj.id}" if tagger_obj       
+            conditions = "(" << conditions << counter_conditions.join(" AND ") << ") = ?"
+            conditions = [conditions, tag_list, tag_list.size]          
+            query.merge!(:conditions => conditions)
+          end
+          taggable_class.all(query)
+        end
+        
+        def fetch(name)
+          first(:name => name) || create(:name => name)
+        end
+        
+        def get(name)
+          first(:name => name)
+        end
+        
+        private        
+        def tagger=(tagger)
+          unless (tagger.respond_to?(:tagger?) && tagger.tagger?) || tagger.nil?
+            raise Exception.new("#{tagger} is not a tagger datamapper resource object!")
+          end
+          @tagger = tagger
+        end
+      end # ClassMethods
+
+      module TagInstanceMethods
+        def <=>(other)
+          self.name <=>(other.name)
+        end
+        def to_s
+          self.name
+        end
+        
+       # Returns an array of related tags.
+       # Related tags are all the other tags that are found  tagged with the provided tags.
+        def related
+          sql = "SELECT count(*) AS count, tag_id
+                 FROM
+                  (SELECT DISTINCT t2.tag_id AS tag_id, t2.tagger_id, t2.tagger_type, t2.taggable_id, t2.taggable_type
+                  FROM taggings AS t1 
+                  INNER JOIN taggings AS t2 
+                  ON ( t2.taggable_id = t1.taggable_id AND t2.taggable_type = t1.taggable_type) 
+                  WHERE t1.tag_id = #{self.id} AND t2.tag_id != #{self.id})
+                 AS a
+                 GROUP BY tag_id 
+                 HAVING count(*) > 1
+                 ORDER BY count(*) DESC;"
+                 
+           # get a hash with tag_id => tag count
+           tags = repository.adapter.query(sql).inject({}){|h, t| h[t[1].to_i] = t[0].to_i; h}
+           
+           # get all the tag resources
+           tag_objects = Tag.all(:id => tags.keys)
+           
+           # turn it into an array like this [[count, tag], [count, tag] ...]
+           # sorted by count in descending order
+           tag_objects.collect do |t|
+             [tags[t.id], t]
+           end.sort{|a, b| a[0] <=> b[0]}.reverse
+         end
+        
+        def popular_by_tags
+          sql= "SELECT tagger_type, tagger_id, COUNT( taggable_id ) AS counter
+                    FROM taggings
+                    INNER JOIN tags ON taggings.tag_id = tags.id
+                    WHERE tags.name = '#{self.name}'
+                    GROUP BY tagger_type, tagger_id
+                    ORDER BY counter DESC"
+          tagger_columns = repository.adapter.query(sql)
+          tagger_hash = {}
+          counter_hash = {}
+          # group all keys
+          tagger_columns.each do |t|
+            t = t.to_a
+            tagger_hash[t[0]] ||= []
+            tagger_hash[t[0]] << t[1]
+            count = t.pop
+            counter_hash[t] = count
+          end
+          taggers = []
+          # find all taggers
+          tagger_hash.each_pair do |key, value|
+            taggers = taggers + Extlib::Inflection.constantize(key).all(:id => value)
+          end
+          # sort the taggers by count
+          taggers.sort! do |a, b|
+            counter_hash[[a.class.to_s, a.id]] <=>counter_hash[[b.class.to_s, b.id]]
+          end.reverse!
+
+          taggers
+        end
+        
+        def tagged_together_count
+        end
+        
+        def tagged_count(conditions={})
+          taggable_class, taggable_obj = extract_taggable_class_object(conditions.delete(:on))
+          tagger_class, tagger_obj = extract_tagger_class_object(conditions.delete(:by))
+          
+          association = if taggable_class && taggable_class.is_a?(Class) && taggable_class.taggable?
+            taggable_class.all.taggings
+          else
+            Tagging.all
+          end
+          
+          association = association.all(:tagger_type => tagger_class.to_s) if tagger_class
+          association = association.all(:tagger_id => tagger_obj.id) if tagger_obj
+
+          query = {:unique => true, :tag_id => self.id, :fields => [:taggable_type]}
+          query.merge!(conditions)
+          
+          association.aggregate(:taggable_id.count, query).inject(0){|count, i| count + i[1]}
+        end
+      end # InstanceMethods
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module DataMapper
+  module Is
+    module Taggable
+
+      def is_taggable(options)
+        extend  DataMapper::Is::Taggable::SharedClassMethods
+        include DataMapper::Is::Taggable::SharedInstanceMethods
+        extend  DataMapper::Is::Taggable::TaggableClassMethods
+        include DataMapper::Is::Taggable::TaggableInstanceMethods
+        
+        @tagger_classes = options[:by]
+        Tag.instance_variable_set('@tagger_classes', (Tag.instance_variable_get('@tagger_classes') | @tagger_classes))
+        
+        has n, :taggings, :class_name => "Tagging", :child_key => [:taggable_id], :taggable_type => self.to_s
+        # real ugly syntax... wait until dm make better conditional has n :through association better, than update code
+        has n,  :tags, :through => :taggings, :class_name => "Tag", 
+                    :child_key => [:taggable_id], 
+                    Tagging.properties[:taggable_type] => self.to_s, 
+                    :unique => true
+        
+        tagger_classes.each do |class_name|
+          has n, "taggings_by_#{class_name.snake_case.plural}".intern, 
+                  :class_name => "Tagging", :child_key => [:taggable_id], 
+                  :taggable_type => self.to_s, :tagger_type => class_name
+                  
+          has n, "tags_by_#{class_name.snake_case.plural}".intern, :through => :taggings, 
+                  :class_name => "Tag", :child_key => [:taggable_id], 
+                  Tagging.properties[:taggable_type] => self.to_s,
+                  Tagging.properties[:tagger_type] => class_name,
+                  :remote_name => "tag"
+                
+          class_eval <<-TAGS
+            def count_tags_by_#{class_name.snake_case.plural}(conditions={})
+              conditions = {:unique => true}.merge(conditions)
+              tags_by_#{class_name.snake_case.plural}.count(:id, conditions)
+            end
+          TAGS
+        end
+        
+        after :save, :tag_now_with_taglist
+        before :destroy, :destroy_all_taggings
+      end
+      
+      module TaggableClassMethods
+        def tagger_classes
+          @tagger_classes.map{|klass| klass.to_s.singular.camel_case}
+        end
+        
+        def tagger?;false;end
+        def taggable?;true;end
+        def taggable_class;self;end
+        
+        def find(options)
+           tagger, taggable, tags, options = extract_options(options)
+           options.merge!(:on => self, :by =>tagger, :with => tags)
+          Tag.find_taggables(options)
+        end
+      end # ClassMethods
+
+      module TaggableInstanceMethods
+        def tagger?;false;end
+        def taggable?;true;end
+        def taggable_class;self.class;end
+        def taggable;self;end
+        
+        def taglist
+          @taglist || TagList.new(self.tags.collect{|t| t.name}).to_s
+        end
+        
+        def taglist=(ataglist)
+          # if the object is a new record, we will tag the object after save
+          # if the object isn't a new record, we tag the object now
+          @taglist = ataglist
+          tag_now_with_taglist unless new_record?
+          true
+        end
+        
+        def can_tag_by?(tagger)
+          if tagger.is_a?(Class)
+            return self.class.tagger_classes.include?(tagger)
+          end
+          return self.class.tagger_classes.include?(tagger.class)
+        end
+        
+        def tag(options)
+          tagger, taggable, tags = extract_options(options)
+          taggable = self
+          # TODO: verify tagger and taggable
+          self.class.create_taggings(tagger, taggable, tags)
+        end
+        
+        def count_tags(conditions={})
+          conditions = {:unique => true}.merge(conditions)
+          tags.count(:id, conditions)
+        end
+        
+        protected
+        def tag_now_with_taglist
+          return unless @taglist 
+          # Destroy all the taggings
+          destroy_all_taggings unless self.new_record?
+
+          # Tag with the tag list
+          self.tag(:with => TagList.from(@taglist))
+          @taglist = nil   
+        end
+
+        def destroy_all_taggings
+          self.taggings.destroy!
+        end
+      end # InstanceMethods
+    end # Taggable
+  end # Is
+end # DataMapper

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

@@ -0,0 +1,80 @@
+module DataMapper
+  module Is
+    module Taggable
+      
+      def is_tagger(options)
+        extend  DataMapper::Is::Taggable::SharedClassMethods
+        include DataMapper::Is::Taggable::SharedInstanceMethods
+        extend  DataMapper::Is::Taggable::TaggerClassMethods
+        include DataMapper::Is::Taggable::TaggerInstanceMethods
+
+        @taggable_classes = options[:on]
+        Tag.instance_variable_set('@taggable_classes', (Tag.instance_variable_get('@taggable_classes') | @taggable_classes))
+        
+        has n, :taggings, :class_name => "Tagging", :child_key => [:tagger_id], :tagger_type => self.to_s
+        # real ugly syntax... wait until dm make better conditional has n :through association better, than update code
+        has n, :tags, :through => :taggings, :class_name => "Tag", :child_key => [:tagger_id], Tagging.properties[:tagger_type] => self.to_s
+      end
+      
+      module TaggerClassMethods 
+        def taggable_classes
+          @taggable_classes.map{|klass| Extlib::Inflection.constantize(klass.to_s.singular.camel_case)}
+        end
+        
+        def tagger?;true;end
+        def taggable?;false;end
+        def tagger_class;self;end
+        
+      end # ClassMethods
+
+      module TaggerInstanceMethods
+        def tagger?;true;end
+        def taggable?;false;end
+        def tagger_class;self.class;end
+        def tagger;self;end
+        
+        def can_tag_on?(taggable)
+          if taggable.is_a?(Class)
+            return self.class.taggable_classes.include?(taggable)
+          end
+          return self.class.taggable_classes.include?(taggable.class)
+        end
+
+        def find_taggables(options)
+          tagger, taggable, tag_list, options = extract_options(options)
+          tagger = self
+          Tag.find_taggables(options.merge(:with => tag_list, :on =>taggable, :by => tagger))
+        end
+        
+        def tag(options)
+          tagger, taggable, tags = extract_options(options)
+          tagger = self
+          self.class.create_taggings(tagger, taggable, tags)
+        end
+        
+        def all_similar_by_tags
+          # this magic query is basically looking at the taggings table,
+          #  searching for taggings having a corresponding tagging from the current taggable object with the same tag_id
+          #  grouping by tagger_id and counting how many are they
+          sql = "SELECT count(*), tagger_id 
+                 FROM (
+                   SELECT DISTINCT t1.tag_id, t1.tagger_id AS tagger_id 
+                   FROM taggings AS t1 
+                   INNER JOIN taggings AS t2 
+                   ON ( t2.tag_id = t1.tag_id AND t2.tagger_type = '#{self.class.to_s}' AND t2.tagger_id = #{self.id}) 
+                   WHERE t1.tagger_type = '#{self.class.to_s}' AND t1.tagger_id != #{self.id}
+                 )
+                 AS a 
+                 GROUP BY tagger_id;"
+        
+          
+          taggers = repository.adapter.query(sql)
+          
+          # for each other taggers, we have the number of tags in common and the tagger object
+          # we order the result by similarity descending
+          taggers.collect{|tagger| [tagger[0], self.class.get(tagger[1])]}.sort {|x,y| y[0]<=>x[0]}
+        end
+      end # InstanceMethods
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module DataMapper
+  module Is
+    module Taggable
+      
+      def is_tagging(options=nil)
+        extend  DataMapper::Is::Taggable::SharedClassMethods
+        include DataMapper::Is::Taggable::SharedInstanceMethods
+        extend  DataMapper::Is::Taggable::TaggingClassMethods
+        include DataMapper::Is::Taggable::TaggingInstanceMethods
+
+        property :id, DataMapper::Types::Serial
+        property :tag_id, Integer,        :index => :true,      :nullable => false
+
+        property :tagger_id, Integer,     :index => :tagger,    :nullable => true
+        property :tagger_type, String,    :index => :tagger,    :nullable => true,  :size => 255
+
+        property :taggable_id, Integer,   :index => :taggable,  :nullable => false
+        property :taggable_type, String,  :index => :taggable,  :nullable => false, :size => 255
+        
+        belongs_to :tag
+      end
+      
+      module TaggingClassMethods
+      end
+
+      module TaggingInstanceMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module DataMapper
+  module Is
+    module Taggable
+      VERSION = "0.1"
+      DEPENDENCY_VERSION = "0.9.6"
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+class Tag
+  include DataMapper::Resource
+  is :tag
+end

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

@@ -0,0 +1,113 @@
+# Backporting the ends_with? method from Rails' ActiveSupport
+class String
+  def ends_with?(suffix)
+    suffix = suffix.to_s
+    self[-suffix.length, suffix.length] == suffix     
+  end
+end
+
+class TagList < Array
+  cattr_accessor :delimiter
+  self.delimiter = ','
+  
+  def initialize(*args)
+    add(*args)
+  end
+  
+  # Add tags to the tag_list. Duplicate or blank tags will be ignored.
+  #
+  #   tag_list.add("Fun", "Happy")
+  # 
+  # Use the <tt>:parse</tt> option to add an unparsed tag string.
+  #
+  #   tag_list.add("Fun, Happy", :parse => true)
+  def add(*names)
+    extract_and_apply_options!(names)
+    concat(names)
+    clean!
+    self
+  end
+  
+  # Remove specific tags from the tag_list.
+  # 
+  #   tag_list.remove("Sad", "Lonely")
+  #
+  # Like #add, the <tt>:parse</tt> option can be used to remove multiple tags in a string.
+  # 
+  #   tag_list.remove("Sad, Lonely", :parse => true)
+  def remove(*names)
+    extract_and_apply_options!(names)
+    delete_if { |name| names.include?(name) }
+    self
+  end
+  
+  # Toggle the presence of the given tags.
+  # If a tag is already in the list it is removed, otherwise it is added.
+  def toggle(*names)
+    extract_and_apply_options!(names)
+    
+    names.each do |name|
+      include?(name) ? delete(name) : push(name)
+    end
+    
+    clean! 
+    self
+  end
+  
+  # Transform the tag_list into a tag string suitable for edting in a form.
+  # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+  #
+  #   tag_list = TagList.new("Round", "Square,Cube")
+  #   tag_list.to_s # 'Round, "Square,Cube"'
+  def to_s
+    clean!
+    
+    map do |name|
+      name.include?(delimiter) ? "\"#{name}\"" : name
+    end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
+  end
+  
+ private
+  # Remove whitespace, duplicates, and blanks.
+  def clean!
+    reject!{|t| t.blank?}
+    map!{|t| t.strip}
+    uniq!
+  end
+  
+  def extract_and_apply_options!(args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+  
+    if options[:parse]
+      args.map! { |a| self.class.from(a) }
+    end
+    
+    args.flatten!
+  end
+  
+  class << self
+    # Returns a new TagList using the given tag string.
+    # 
+    #   tag_list = TagList.from("One , Two,  Three")
+    #   tag_list # ["One", "Two", "Three"]
+    def from(source)
+      tag_list = TagList.new
+      case source
+        when Array
+          source.each{|a| tag_list.add(TagList.from(a))}
+        else
+          string = source.to_s.dup
+          # Parse the quoted tags
+          [
+            /\s*#{delimiter}\s*(['"])(.*?)\1\s*/,
+            /^\s*(['"])(.*?)\1\s*#{delimiter}?/
+          ].each do |re|
+            string.gsub!(re) { tag_list << $2; "" }
+          end
+          tag_list.add(string.split(delimiter))
+      end
+      
+      tag_list
+    end
+  end
+end