cldwalker-has_machine_tags 0.1.2 → 0.1.3

data/README.rdoc

@@ -18,10 +18,14 @@ Install as a gem
 
     bash> gem install cldwalker-has_machine_tags -s http://gems.github.com
 
+    # add in your environment.rb
+    config.gem "cldwalker-has_machine_tags", :source => "http://gems.github.com", :lib => "has_machine_tags"
+
 Or as a plugin
 
     bash> script/plugin install git://github.com/cldwalker/has_machine_tags.git
 
+
 Migrate your database from Rails root:
   
     bash> script/generate has_machine_tags_migration
@@ -128,7 +132,7 @@ these characters are off limit unless used in the machine tag context:
 
 == Credits
 
-Thanks goes to Flickr for implementing this clever tagging model.
+Thanks goes to Flickr for popularizing this tagging model.
 Thanks also goes to the {acts-as-taggable-on plugin}[http://github.com/mbleigh/acts-as-taggable-on/tree/master]
 for their finder code and the {is_taggable plugin}[http://github.com/giraffesoft/is_taggable/tree/master]
 for demonstrating sane testing for a Rails plugin.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.rcov_opts = ["-T -x '/Library/Ruby/*'"]
+    t.verbose = true
+  end
+rescue LoadError
+  puts "Rcov not available. Install it for rcov-related tasks with: sudo gem install rcov"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "has_machine_tags"
+    s.description = "A rails tagging plugin implementing flickr's machine tags + maybe more (semantic tags)"
+    s.summary = s.description
+    s.email = "gabriel.horner@gmail.com"
+    s.homepage = "http://github.com/cldwalker/has_machine_tags"
+    s.authors = ["Gabriel Horner"]
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
+    s.files = FileList["README.rdoc", "LICENSE.txt", "init.rb", "Rakefile", "VERSION.yml", "{generators,bin,lib,test}/**/*"]
+  end
+
+rescue LoadError
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'test'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 3

data/init.rb

@@ -0,0 +1,5 @@
+require 'has_machine_tags'
+require 'has_machine_tags/tag'
+require 'has_machine_tags/tagging'
+
+ActiveRecord::Base.send :include, HasMachineTags

data/lib/has_machine_tags/namespace_group.rb

@@ -0,0 +1,146 @@
+module HasMachineTags
+  # These classes are used for querying machine tags and grouping results as outlines.
+  # These methods are for console use and may change quickly.
+  class NamespaceGroup #:nodoc:
+    def initialize(name, options={})
+      @name = name.to_s
+      @options = options
+      @tags = options[:tags] if options[:tags]
+    end
+    
+    def tags
+      @tags ||= Tag.find_all_by_namespace(@name)
+    end
+    
+    def predicates
+      tags.map(&:predicate)
+    end
+
+    def values
+      tags.map(&:value)
+    end
+
+    def predicate_map
+      tags.map {|e| [e.predicate, e.value] }.inject({}) {
+        |t, (k,v)| (t[k] ||=[]) << v; t
+      }
+    end
+    alias :pm :predicate_map
+    
+    def value_count(pred,value)
+      Url.tagged_with("#{@name}:#{pred}=#{value}").count
+    end
+    
+    def pred_count(pred)
+      (predicate_map[pred] ||[]).map {|e| [e, value_count(pred, e)]}
+    end
+    
+    def group_pred_count(pred)
+      pred_count(pred).inject({}) {|hash,(k,v)|
+        (hash[v] ||= []) << k
+        hash
+      }
+    end
+    
+    def sort_group_pred_count(pred)
+      hash = group_pred_count(pred)
+      hash.keys.sort.reverse.map {|e|
+        [e, hash[e]]
+      }
+    end
+    
+    def predicate_view(pred, view=nil)
+      if view == :group
+        sort_group_pred_count(pred).map {|k,v|
+          "#{k}: #{v.join(', ')}"
+        }
+      elsif view == :count
+        pred_count(pred).map {|k,v|
+          "#{k}: #{v}"
+        }
+      else
+        nil
+      end
+    end
+    
+    def outline_view(type=nil)
+      body = [@name]
+      level_delim = "\t"
+      predicate_map.each do |pred, vals|
+        body << [level_delim + pred]
+        values = predicate_view(pred, type) || vals
+        values.each {|e|
+            body << level_delim * 2 + e
+            if type == :result
+              urls = Url.tagged_with("#{@name}:#{pred}=#{e}")
+              urls.each {|u|
+                body << level_delim * 3 + format_result(u)
+              }
+            end
+        }
+      end
+      body.join("\n")
+    end
+    
+    def format_result(result)
+      "#{result.id}: #{result.name}"
+    end
+
+    def inspect
+      outline_view(@options[:view])
+    end
+    
+    def duplicate_values
+      array_duplicates(values)
+    end
+    
+    def array_duplicates(array)
+        hash = array.inject({}) {|h,e|
+          h[e] ||= 0
+          h[e] += 1
+          h
+        }
+        hash.delete_if {|k,v| v<=1}
+        hash.keys
+    end
+    
+  end
+  
+  class TagGroup < NamespaceGroup #:nodoc:
+    def namespaces
+      tags.map(&:namespace).uniq
+    end
+    
+    def outline_view(type=nil)
+      "\n" + namespace_groups.map {|e| e.outline_view(type) }.join("\n")
+    end
+    
+    def inspect; super; end
+    
+    def namespace_tags
+      tags.inject({}) {|h,t|
+        (h[t.namespace] ||= []) << t
+        h
+      }
+    end
+    
+    def namespace_groups
+      unless @namespace_groups
+        @namespace_groups = namespace_tags.map {|name, tags|
+          NamespaceGroup.new(name, :tags=>tags)
+        }
+      end
+      @namespace_groups
+    end
+    
+    def tags
+      @tags ||= Tag.machine_tags(@name)
+    end
+  end
+  
+  class QueryGroup < TagGroup #:nodoc:
+    def tags
+      @tags ||= Url.tagged_with(@name).map(&:tags).flatten.uniq
+    end
+  end
+end

data/lib/has_machine_tags/tag.rb

@@ -1,5 +1,5 @@
 # == Machine Tags
-# Machine tags are in the format: 
+# Machine tags, also known as triple tags, are in the format: 
 #   [namespace]:[predicate]=[value]
 # 
 # As explained here[http://www.flickr.com/groups/api/discuss/72157594497877875],
@@ -65,12 +65,13 @@
 
 class Tag < ActiveRecord::Base
   has_many :taggings
+  
   validates_presence_of :name
   validates_uniqueness_of :name
   before_save :update_name_related_columns
   
   NAMESPACE_REGEX = "[a-z](?:[a-z0-9_]+)"
-  PREDICATE_REGEX = "[a-z](?:[a-z0-9_]+)"
+  PREDICATE_REGEX = "[a-z](?:[a-z0-9_-]+)"
   VALUE_REGEX = '.+'
 
   #disallow machine tags special characters and tag list delimiter OR allow machine tag format
@@ -79,16 +80,21 @@ class Tag < ActiveRecord::Base
   named_scope :namespace_counts, :select=>'*, namespace as counter, count(namespace) as count', :group=>"namespace HAVING count(namespace)>=1"
   named_scope :predicate_counts, :select=>'*, predicate as counter, count(predicate) as count', :group=>"predicate HAVING count(predicate)>=1"
   named_scope :value_counts, :select=>'*, value as counter, count(value) as count', :group=>"value HAVING count(value)>=1"
-  named_scope :namespace, lambda {|namespace| {:conditions=>{:namespace=>namespace}} }
-  named_scope :predicate, lambda {|predicate| {:conditions=>{:predicate=>predicate}} }
-  named_scope :value, lambda {|value| {:conditions=>{:value=>value}} }
+  named_scope :distinct_namespaces, :select=>"distinct namespace"
+  named_scope :distinct_predicates, :select=>"distinct predicate"
+  named_scope :distinct_values, :select=>"distinct value"
 
+  def self.namespaces; distinct_namespaces.map(&:namespace).compact; end
+  def self.predicates; distinct_predicates.map(&:predicate).compact; end
+  def self.values; distinct_values.map(&:value).compact; end
+  
   # To be used with the *counts methods.
   # For example:
   #   stat(:namespace_counts) 
   # This prints out pairs of a namespaces and their counts in the tags table.
   def self.stat(type)
-    send(type).map {|e| [e.counter, e.count] }
+    shortcuts = {:n=>:namespace_counts, :p=>:predicate_counts, :v=>:value_counts }
+    send(shortcuts[type] || type).map {|e| [e.counter, e.count] }
   end
 
   # Takes a wildcard machine tag and returns matching tags.

data/lib/has_machine_tags/tagging.rb

@@ -1,3 +1,4 @@
 class Tagging < ActiveRecord::Base
   belongs_to :tag
+  belongs_to :taggable, :polymorphic => true
 end

data/lib/has_machine_tags.rb

@@ -7,8 +7,12 @@ module HasMachineTags
     base.extend(ClassMethods)
   end
   
-  module ClassMethods #:nodoc:
-    def has_machine_tags
+  module ClassMethods
+    # Options
+    #   :reverse_has_many - Defines a has_many :through from tags to the model using the plural of the model name.
+    def has_machine_tags(options={})
+      cattr_accessor :quick_mode
+      self.quick_mode = options[:quick_mode] || false
       self.class_eval do
         has_many :taggings, :as=>:taggable, :dependent=>:destroy
         has_many :tags, :through=>:taggings
@@ -17,11 +21,17 @@ module HasMachineTags
         include HasMachineTags::InstanceMethods
         extend HasMachineTags::SingletonMethods
         if respond_to?(:named_scope)
-          named_scope :tagged_with, lambda{ |tags, options|
-            find_options_for_find_tagged_with(tags, options)
+          named_scope :tagged_with, lambda{ |*args|
+            find_options_for_find_tagged_with(*args)
           }
         end
       end
+      if options[:reverse_has_many]
+        model = self.to_s
+        'Tag'.constantize.class_eval do
+          has_many(model.tableize, :through => :taggings, :source => :taggable, :source_type =>model)
+        end
+      end
     end
   end
   
@@ -30,17 +40,17 @@ module HasMachineTags
     # Note that each tag is interpreted as a possible wildcard machine tag.
     # 
     # Options:
-    #   :exclude - Find models that are not tagged with the given tags
-    #   :match_all - Find models that match all of the given tags, not just one, default: true
-    #   :conditions - A piece of SQL conditions to add to the query
+    #   :exclude - Find models that are not tagged with the given tags.
+    #   :match_all - Find models that match all of the given tags, not just one (doesn't work with machine tags yet).
+    #   :conditions - A piece of SQL conditions to add to the query.
     #
     # Example:
     #  Url.tagged_with 'something' # => fetches urls tagged with 'something'
     #  Url.tagged_with 'gem:'      # => fetches urls tagged with tags that have namespace gem
-    #  Url.tagged_with 'gem:, something' # =>  fetches urls that are tagged with 'something'
-    #    and tags that have namespace gem
+    #  Url.tagged_with 'gem, something' # =>  fetches urls that are tagged with 'something'
+    #    and 'gem'
     #   
-    #  Note: This method really only needs to be used for Rails < 2.1 . 
+    #  Note: This method really only needs to be used with Rails < 2.1 . 
     #  Rails 2.1 and greater should use tagged_with(), which acts the same but with
     #  the benefits of named_scope.
     #
@@ -50,7 +60,7 @@ module HasMachineTags
     end
     
     def find_options_for_find_tagged_with(tags, options = {}) #:nodoc:
-      options.reverse_merge!(:match_all=>true)
+      # options.reverse_merge!(:match_all=>true)
       tags = TagList.new(tags)
       return {} if tags.empty?
 
@@ -59,12 +69,14 @@ module HasMachineTags
       
       taggings_alias, tags_alias = "#{table_name}_taggings", "#{table_name}_tags"
       
+      machine_tag_used = false
       if options.delete(:exclude)
         tags_conditions = tags.map { |t| sanitize_sql(["#{Tag.table_name}.name = ?", t]) }.join(" OR ")
         conditions << sanitize_sql(["#{table_name}.id NOT IN (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name} LEFT OUTER JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id WHERE (#{tags_conditions}) AND #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})", tags])
       else
-        conditions << tags.map {|t|
+        tag_sql = tags.map {|t|
           if match = Tag.match_wildcard_machine_tag(t)
+            machine_tag_used = true
             string = match.map {|k,v|
               sanitize_sql(["#{tags_alias}.#{k} = ?", v])
             }.join(" AND ")
@@ -73,9 +85,17 @@ module HasMachineTags
             sanitize_sql(["#{tags_alias}.name = ?", t])
           end
         }.join(" OR ")
-
+        conditions << tag_sql
+        
         if options.delete(:match_all)
-          group = "#{taggings_alias}.taggable_id HAVING COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
+          group = "#{taggings_alias}.taggable_id HAVING COUNT(#{taggings_alias}.taggable_id) = "
+          if machine_tag_used
+            #Since a machine tag matches multiple tags per given tag, we need to dynamically calculate the count
+            #TODO: this select needs to return differently for each taggable_id
+            group += "(SELECT count(id) FROM #{Tag.table_name} #{tags_alias} WHERE #{tag_sql})"
+          else
+            group += tags.size.to_s
+          end
         end
       end
       
@@ -89,9 +109,25 @@ module HasMachineTags
   end
   
   module InstanceMethods
+    
+    def quick_mode_tag_list(list) #:nodoc:
+      mtag_list = TagList.new(list)
+      mtag_list = mtag_list.map {|e|
+        if e.include?(":")
+          namespace,other = e.split(":")
+          other.split(";").map {|e| 
+            e.include?("=") ? "#{namespace}:#{e}" : "#{namespace}:tags=#{e}"
+          }
+        else
+          e
+        end
+      }.flatten
+      TagList.new(mtag_list)
+    end
+    
     # Set tag list with an array of tags or comma delimited string of tags
     def tag_list=(list)
-      @tag_list = TagList.new(list)
+      @tag_list = quick_mode ? quick_mode_tag_list(list) : TagList.new(list)
     end
 
     # Fetches latest tag list for an object

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cldwalker-has_machine_tags
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Gabriel Horner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-12 00:00:00 -08:00
+date: 2009-02-20 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -25,11 +25,15 @@ extra_rdoc_files:
 files: 
 - README.rdoc
 - LICENSE.txt
+- init.rb
+- Rakefile
+- VERSION.yml
 - generators/has_machine_tags_migration
 - generators/has_machine_tags_migration/has_machine_tags_migration_generator.rb
 - generators/has_machine_tags_migration/templates
 - generators/has_machine_tags_migration/templates/migration.rb
 - lib/has_machine_tags
+- lib/has_machine_tags/namespace_group.rb
 - lib/has_machine_tags/tag.rb
 - lib/has_machine_tags/tag_list.rb
 - lib/has_machine_tags/tagging.rb