cldwalker-has_machine_tags 0.1.3 → 0.1.4

data/README.rdoc

@@ -9,9 +9,11 @@ Basically, a machine tag has a namespace, a predicate and a value in the format
 
 This allows for more precise tagging as tags can have unlimited contexts provided
 by combinations of namespaces and predicates. These unlimited contexts also make
-machine tags ripe for modeling relationships between objects. Read the Tag class
+machine tags ripe for modeling relationships between objects. Read the HasMachineTags::TagMethods class
 documentation for a more thorough explanation.
 
+A demo app using this plugin is {here}[http://github.com/cldwalker/tag-tree].
+
 == Install
 
 Install as a gem

data/Rakefile

@@ -25,7 +25,7 @@ begin
     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}/**/*"]
+    s.files = FileList["README.rdoc", "LICENSE.txt", "init.rb", "Rakefile", "VERSION.yml", "{rails,generators,bin,lib,test}/**/*"]
   end
 
 rescue LoadError

data/VERSION.yml

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

data/init.rb

@@ -1,5 +1 @@
-require 'has_machine_tags'
-require 'has_machine_tags/tag'
-require 'has_machine_tags/tagging'
-
-ActiveRecord::Base.send :include, HasMachineTags
+require File.join(File.dirname(__FILE__), 'rails', 'init.rb')

data/lib/has_machine_tags/console.rb

@@ -0,0 +1,44 @@
+module HasMachineTags
+  # Methods for console/irb use.
+  module Console
+    module InstanceMethods
+      # Removes first list, adds second list and saves changes.
+      def tag_add_and_remove(remove_list, add_list)
+        self.class.transaction do
+          tag_add_and_save(add_list)
+          tag_remove_and_save(remove_list)
+        end
+      end
+
+      # Adds given list and saves.
+      def tag_add_and_save(add_list)
+        self.tag_list = self.tag_list + current_tag_list(add_list)
+        self.save
+        self.tag_list
+      end
+      
+      # Removes given list and saves.
+      def tag_remove_and_save(remove_list)
+        self.tag_list = self.tag_list - current_tag_list(remove_list)
+        self.save
+        self.tag_list
+      end
+      
+      # Resets tag_list to given tag_list and saves.
+      def tag_and_save(tag_list)
+        self.tag_list = tag_list
+        self.save
+        self.tag_list
+      end
+    end
+    
+    module ClassMethods
+      # Updates items tagged with an old tag to use the given new tag in place of the old tag.
+      def find_and_change_tag(old_tag, new_tag)
+        results = tagged_with(old_tag)
+        results.each {|e| e.tag_add_and_remove(old_tag, new_tag)}
+        puts "Changed tag for #{results.length} records"
+      end
+    end
+  end
+end

data/lib/has_machine_tags/singleton_methods.rb

@@ -0,0 +1,91 @@
+module HasMachineTags
+  module SingletonMethods
+    # Takes a string of delimited tags or an array of tags.
+    # Note that each tag is interpreted as a possible wildcard machine tag.
+    # 
+    # Options:
+    #   :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'
+    #    or 'gem'
+    #   
+    #  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.
+    #
+    def find_tagged_with(*args)
+      options = find_options_for_tagged_with(*args)
+      options.blank? ? [] : find(:all,options)
+    end
+    
+    # :stopdoc:
+    def find_options_for_tagged_with(tags, options = {})
+      tags = TagList.new(tags)
+      return {} if tags.empty?
+      conditions = []
+      conditions << sanitize_sql(options.delete(:conditions)) if options[:conditions]
+      conditions << condition_from_tags(tags)
+      default_find_options_for_tagged_with.update(:conditions=>conditions.join(" AND ")).update(options)
+    end
+    
+    def condition_from_tags(tags)
+      tag_sql = tags.map {|t|
+        if match = Tag.match_wildcard_machine_tag(t)
+          string = match.map {|k,v|
+            sanitize_sql(["#{tags_alias}.#{k} = ?", v])
+          }.join(" AND ")
+          "(#{string})"
+        else
+          sanitize_sql(["#{tags_alias}.name = ?", t])
+        end
+      }.join(" OR ")
+    end
+    
+    def taggings_alias
+      "#{table_name}_taggings"
+    end
+    
+    def tags_alias
+      "#{table_name}_tags"
+    end
+      
+    def default_find_options_for_tagged_with
+      { :select => "DISTINCT #{table_name}.*",
+        :joins => "LEFT OUTER JOIN #{Tagging.table_name} #{taggings_alias} ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key} AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)} " +
+                  "LEFT OUTER JOIN #{Tag.table_name} #{tags_alias} ON #{tags_alias}.id = #{taggings_alias}.tag_id",
+        # :group      => group
+      }
+    end
+    
+    # TODO: add back in options as needed.
+    # 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 (doesn't work with machine tags yet).
+    def old_find_options_for_find_tagged_with(tags, options = {}) #:nodoc:
+      # options.reverse_merge!(:match_all=>true)
+      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 << condition_from_tags(tags)
+        
+        if options.delete(:match_all)
+          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
+      default_find_options_for_tagged_with.update(:conditions=>conditions.join(" AND ")).update(options)
+    end
+    # :startdoc:
+  end
+end

data/lib/has_machine_tags/tag.rb

@@ -1,143 +1,3 @@
-# == Machine Tags
-# 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],
-# a namespace and predicate must start with a letter a-z while its remaining characters can be any lowercase alphanumeric character
-# and underscore. A value can contain any characters that normal tags use.
-# 
-# == Wildcard Machine Tags
-# Wildcard machine tag syntax is used with Tag.machine_tags() and {tagged_with() or find_tagged_with()}[link:classes/HasMachineTags/SingletonMethods.html] of tagged objects.
-# This syntax allows one to fetch items that fall under a group of tags, as specified by namespace, predicate, value or
-# a combination of these ways. While this plugin supports {Flickr's wildcard format}[http://code.flickr.com/blog/2008/07/18/wildcard-machine-tag-urls/],
-# it also supports its own slightly shorter format.
-#
-# === Examples
-# 
-# For a tag 'user:name=john', the following wildcards would match it:
-#
-# * Wild namespace (any tag with namespace user)
-#     Tag.machine_tags 'user:'   # Our way
-#     Tag.machine_tags 'user:*=' # Flickr way
-#
-# * Wild predicate (any tag with predicate name)
-#     Tag.machine_tags 'name='   # Our way
-#     Tag.machine_tags '*:name=' # Flickr way
-#
-# * Wild predicate (any tag with value john)
-#     Tag.machine_tags '=john'    # Our way
-#     Tag.machine_tags '*:*=john' # Flickr way
-#
-# * Wild namespace and predicate (any tag with namespace user and predicate name)
-#     Tag.machine_tags 'user:name'  # Our way
-#     Tag.machine_tags 'user:name=' # Flickr way
-#
-# * Wild predicate and value (any tag with predicate name and value john)
-#     Tag.machine_tags 'name=john'   # Our way
-#     Tag.machine_tags '*:name=john' # Flickr way
-#
-# * Wild namespace and value (any tag with namespace user and value john)
-#     Tag.machine_tags 'user.john'   # Our way
-#     Tag.machine_tags 'user:*=john' # Flickr way
-#
-# == Food For Thought
-# So what's so great about being able to give a tag a namespace and a predicate?
-# * It allows for more fine-grained tag queries by giving multiple contexts:
-#
-#   Say instead of having tagged with 'user:name=john' we had tagged with the traditional separate
-#   tags: user, name and john. How would we know that we had meant an item to be tagged
-#   as a user ie with namespace user? We wouldn't know. Any query for 'user' would return
-#   all user-tagged items <b>without context</b>. With machine tags, we can have 'user' refer
-#   to a particular combination of namespace, predicate and value.
-#
-# * It keeps tag-spaces cleaner because there are more contexts:
-#
-#   With traditional separate tags, tags just have a global context. So
-#   if different users decide to give different meaning to the same tag, the tag starts to become
-#   polluted and loses its usefulness. With the limitless contexts provided by machine tags,
-#   a machine tag is less likely to pollute other tags.
-#
-# * It allows tagging to serve as a medium for defining relationships between objects:
-#   
-#   Since a machine tag tracks three attributes (namespace, predicate and value), it's possible to develop relationships
-#   between the attributes. This means namespaces can have many predicates and predicates can have many values.
-#   Since this closely resembles object modeling, we can start to use tagging to form relationships between tagged items and other objects.
-
-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_-]+)"
-  VALUE_REGEX = '.+'
-
-  #disallow machine tags special characters and tag list delimiter OR allow machine tag format
-  validates_format_of :name, :with=>/\A(([^\*\=\:\.,]+)|(#{NAMESPACE_REGEX}\:#{PREDICATE_REGEX}\=#{VALUE_REGEX}))\Z/
-  
-  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 :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)
-    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.
-  def self.machine_tags(name)
-    conditions = if (match = match_wildcard_machine_tag(name))
-      match.map {|k,v|
-        sanitize_sql(["#{k} = ?", v])
-      }.join(" AND ")
-    else
-      sanitize_sql(["name = ?", name])
-    end
-    find(:all, :conditions=>conditions)
-  end
-  
-  # Valid wildcards with their equivalent shortcuts
-  # namespace:*=* -> namespace:
-  # *:predicate=* -> predicate=
-  # *:*=value     -> :value
-  def self.match_wildcard_machine_tag(name) #:nodoc:
-    if name =~ /^(#{NAMESPACE_REGEX}|\*)\:(#{PREDICATE_REGEX}|\*)\=(#{VALUE_REGEX}|\*)?$/
-      result = [[:namespace, $1], [:predicate, $2], [:value, $3]].select {|k,v| ![nil,'*'].include?(v) }
-      result.size == 3 ? nil : result
-    #duo shortcuts
-    elsif name =~ /^(#{NAMESPACE_REGEX}\:#{PREDICATE_REGEX})|(#{PREDICATE_REGEX}\=#{VALUE_REGEX})|(#{NAMESPACE_REGEX}\.#{VALUE_REGEX})$/
-      $1 ? [:namespace, :predicate].zip($1.split(":")) : ($2 ? [:predicate, :value].zip($2.split("=")) :
-        [:namespace, :value].zip($3.split('.')) )
-    #single shortcuts
-    elsif name =~ /^((#{NAMESPACE_REGEX})(?:\:)|(#{PREDICATE_REGEX})(?:\=)|(?:\=)(#{VALUE_REGEX}))$/
-      $2 ? [[:namespace, $2]] : ($3 ? [[:predicate, $3]] : [[:value, $4]])
-    else
-      nil
-    end
-  end
-  
-  def extract_from_name(tag_name) #:nodoc:
-    (tag_name =~ /^(#{NAMESPACE_REGEX})\:(#{PREDICATE_REGEX})\=(#{VALUE_REGEX})$/) ? [$1, $2, $3] : nil
-  end
-
-  private
-  
-  def update_name_related_columns
-    if self.changed.include?('name') && (arr = extract_from_name(self.name))
-      self[:namespace], self[:predicate], self[:value] = arr
-    end
-  end
+class ::Tag < ActiveRecord::Base
+  include HasMachineTags::TagMethods
 end

data/lib/has_machine_tags/tag_list.rb

@@ -1,14 +1,45 @@
 module HasMachineTags
-  class TagList < Array #:nodoc:
+  class TagList < Array
     cattr_accessor :delimiter
     self.delimiter = ','
+    cattr_accessor :default_predicate
+    self.default_predicate = 'tags'
+    QUICK_MODE_DELIMITER = ';'
   
-    def initialize(string_or_array)
+    # ==== Options:
+    # [:quick_mode]  
+    #   When true enables a quick mode for inputing multiple machine tags under the same namespace.
+    #   These machine tags are delimited by QUICK_MODE_DELIMITER. If a predicate is not specified, default_predicate() is used.
+    #     Examples:
+    #     # Namespace is added to tag 'type=test'.
+    #     HasMachineTags::TagList.new("gem:name=flog;type=test, user:name=seattlerb", :quick_mode=>true)
+    #     => ["gem:name=flog", "gem:type=test", "user:name=seattlerb"]
+    #
+    #     # Namespace and default predicate (tags) are added to tag 'git'.
+    #     HasMachineTags::TagList.new("gem:name=grit;git, user:name=mojombo")
+    #     => ["gem:name=grit", "gem:tags=git", "user:name=mojombo"]
+    def initialize(string_or_array, options={})
+      @options = options
       array = string_or_array.is_a?(Array) ? string_or_array : string_or_array.split(/\s*#{delimiter}\s*/)
+      array = parse_quick_mode(array) if @options[:quick_mode]
       concat array
     end
+    
+    def parse_quick_mode(mtag_list) #:nodoc:
+      mtag_list = mtag_list.map {|e|
+        if e.include?(Tag::PREDICATE_DELIMITER)
+          namespace, remainder = e.split(Tag::PREDICATE_DELIMITER)
+          remainder.split(QUICK_MODE_DELIMITER).map {|e| 
+            e.include?(Tag::VALUE_DELIMITER) ? "#{namespace}#{Tag::PREDICATE_DELIMITER}#{e}" :
+            Tag.build_machine_tag(namespace, default_predicate, e)
+          }
+        else
+          e
+        end
+      }.flatten
+    end
   
-    def to_s
+    def to_s #:nodoc:
       join("#{delimiter} ")
     end
   end

data/lib/has_machine_tags/tag_methods.rb

@@ -0,0 +1,165 @@
+module HasMachineTags
+# == Machine Tags
+# 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],
+# a namespace and predicate must start with a letter a-z while its remaining characters can be any lowercase alphanumeric character
+# and underscore. A value can contain any characters that normal tags use.
+# 
+# == Wildcard Machine Tags
+# Wildcard machine tag syntax is used with Tag.machine_tags() and {tagged_with() or find_tagged_with()}[link:classes/HasMachineTags/SingletonMethods.html] of tagged objects.
+# This syntax allows one to fetch items that fall under a group of tags, as specified by namespace, predicate, value or
+# a combination of these ways. While this plugin supports {Flickr's wildcard format}[http://code.flickr.com/blog/2008/07/18/wildcard-machine-tag-urls/],
+# it also supports its own slightly shorter format.
+#
+# === Examples
+# 
+# For a tag 'user:name=john', the following wildcards would match it:
+#
+# * Wild namespace (any tag with namespace user)
+#     Tag.machine_tags 'user:'   # Our way
+#     Tag.machine_tags 'user:*=' # Flickr way
+#
+# * Wild predicate (any tag with predicate name)
+#     Tag.machine_tags 'name='   # Our way
+#     Tag.machine_tags '*:name=' # Flickr way
+#
+# * Wild predicate (any tag with value john)
+#     Tag.machine_tags '=john'    # Our way
+#     Tag.machine_tags '*:*=john' # Flickr way
+#
+# * Wild namespace and predicate (any tag with namespace user and predicate name)
+#     Tag.machine_tags 'user:name'  # Our way
+#     Tag.machine_tags 'user:name=' # Flickr way
+#
+# * Wild predicate and value (any tag with predicate name and value john)
+#     Tag.machine_tags 'name=john'   # Our way
+#     Tag.machine_tags '*:name=john' # Flickr way
+#
+# * Wild namespace and value (any tag with namespace user and value john)
+#     Tag.machine_tags 'user.john'   # Our way
+#     Tag.machine_tags 'user:*=john' # Flickr way
+#
+# == Food For Thought
+# So what's so great about being able to give a tag a namespace and a predicate?
+# * It allows for more fine-grained tag queries by giving multiple contexts:
+#
+#   Say instead of having tagged with 'user:name=john' we had tagged with the traditional separate
+#   tags: user, name and john. How would we know that we had meant an item to be tagged
+#   as a user ie with namespace user? We wouldn't know. Any query for 'user' would return
+#   all user-tagged items <b>without context</b>. With machine tags, we can have 'user' refer
+#   to a particular combination of namespace, predicate and value.
+#
+# * It keeps tag-spaces cleaner because there are more contexts:
+#
+#   With traditional separate tags, tags just have a global context. So
+#   if different users decide to give different meaning to the same tag, the tag starts to become
+#   polluted and loses its usefulness. With the limitless contexts provided by machine tags,
+#   a machine tag is less likely to pollute other tags.
+#
+# * It allows tagging to serve as a medium for defining relationships between objects:
+#   
+#   Since a machine tag tracks three attributes (namespace, predicate and value), it's possible to develop relationships
+#   between the attributes. This means namespaces can have many predicates and predicates can have many values.
+#   Since this closely resembles object modeling, we can start to use tagging to form relationships between tagged items and other objects.
+  module TagMethods
+    NAMESPACE_REGEX = "[a-z](?:[a-z0-9_]+)"
+    PREDICATE_REGEX = "[a-z](?:[a-z0-9_-]+)"
+    VALUE_REGEX = '.+'
+    #TODO: use delimiters in this file
+    PREDICATE_DELIMITER = ':'
+    VALUE_DELIMITER = '='
+
+    def self.included(base) #:nodoc:
+      name_format = /\A(([^\*\=\:\.,]+)|(#{NAMESPACE_REGEX}\:#{PREDICATE_REGEX}\=#{VALUE_REGEX}))\Z/
+      base.class_eval %[
+        has_many :taggings
+  
+        validates_presence_of :name
+        validates_uniqueness_of :name
+        before_save :update_name_related_columns
+  
+        #disallow machine tags special characters and tag list delimiter OR allow machine tag format
+        validates_format_of :name, :with=>name_format
+  
+        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 :distinct_namespaces, :select=>"distinct namespace"
+        named_scope :distinct_predicates, :select=>"distinct predicate"
+        named_scope :distinct_values, :select=>"distinct value"
+      ]
+      base.extend(ClassMethods)
+      base.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+      #:stopdoc:
+      def namespaces; distinct_namespaces.map(&:namespace).compact; end
+      def predicates; distinct_predicates.map(&:predicate).compact; end
+      def values; distinct_values.map(&:value).compact; end
+      #:startdoc:
+  
+      # 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 stat(type)
+        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.
+      def machine_tags(name)
+        conditions = if (match = match_wildcard_machine_tag(name))
+          match.map {|k,v|
+            sanitize_sql(["#{k} = ?", v])
+          }.join(" AND ")
+        else
+          sanitize_sql(["name = ?", name])
+        end
+        find(:all, :conditions=>conditions)
+      end
+      
+      # Builds a machine tag string given namespace, predicate and value.
+      def build_machine_tag(namespace, predicate, value)
+        "#{namespace}:#{predicate}=#{value}"
+      end
+  
+      # Valid wildcards with their equivalent shortcuts
+      # namespace:*=* -> namespace:
+      # *:predicate=* -> predicate=
+      # *:*=value     -> :value
+      def match_wildcard_machine_tag(name) #:nodoc:
+        if name =~ /^(#{NAMESPACE_REGEX}|\*)\:(#{PREDICATE_REGEX}|\*)\=(#{VALUE_REGEX}|\*)?$/
+          result = [[:namespace, $1], [:predicate, $2], [:value, $3]].select {|k,v| ![nil,'*'].include?(v) }
+          result.size == 3 ? nil : result
+        #duo shortcuts
+        elsif name =~ /^(#{NAMESPACE_REGEX}\:#{PREDICATE_REGEX})|(#{PREDICATE_REGEX}\=#{VALUE_REGEX})|(#{NAMESPACE_REGEX}\.#{VALUE_REGEX})$/
+          $1 ? [:namespace, :predicate].zip($1.split(":")) : ($2 ? [:predicate, :value].zip($2.split("=")) :
+            [:namespace, :value].zip($3.split('.')) )
+        #single shortcuts
+        elsif name =~ /^((#{NAMESPACE_REGEX})(?:\:)|(#{PREDICATE_REGEX})(?:\=)|(?:\=)(#{VALUE_REGEX}))$/
+          $2 ? [[:namespace, $2]] : ($3 ? [[:predicate, $3]] : [[:value, $4]])
+        else
+          nil
+        end
+      end
+    end
+  
+    module InstanceMethods
+      def extract_from_name(tag_name) #:nodoc:
+        (tag_name =~ /^(#{NAMESPACE_REGEX})\:(#{PREDICATE_REGEX})\=(#{VALUE_REGEX})$/) ? [$1, $2, $3] : nil
+      end
+
+      private
+  
+      def update_name_related_columns
+        if self.changed.include?('name') && (arr = extract_from_name(self.name))
+          self[:namespace], self[:predicate], self[:value] = arr
+        end
+      end
+    end
+  end
+end

data/lib/has_machine_tags.rb

@@ -1,6 +1,8 @@
 current_dir = File.dirname(__FILE__)
 $:.unshift(current_dir) unless $:.include?(current_dir) || $:.include?(File.expand_path(current_dir))
+require 'has_machine_tags/singleton_methods'
 require 'has_machine_tags/tag_list'
+require 'has_machine_tags/console'
 
 module HasMachineTags
   def self.included(base) #:nodoc:
@@ -8,8 +10,10 @@ module HasMachineTags
   end
   
   module ClassMethods
-    # Options
-    #   :reverse_has_many - Defines a has_many :through from tags to the model using the plural of the model name.
+    # ==== Options:
+    # [:console] When true, adds additional helper methods from HasMachineTags::Console to use mainly in irb.
+    # [:reverse_has_many] Defines a has_many :through from tags to the model using the plural of the model name.
+    # [:quick_mode] When true, enables a quick mode to input machine tags with HasMachineTags::InstanceMethods.tag_list=(). See examples at HasMachineTags::TagList.new().
     def has_machine_tags(options={})
       cattr_accessor :quick_mode
       self.quick_mode = options[:quick_mode] || false
@@ -20,9 +24,13 @@ module HasMachineTags
         
         include HasMachineTags::InstanceMethods
         extend HasMachineTags::SingletonMethods
+        if options[:console]
+          include HasMachineTags::Console::InstanceMethods
+          extend HasMachineTags::Console::ClassMethods
+        end
         if respond_to?(:named_scope)
           named_scope :tagged_with, lambda{ |*args|
-            find_options_for_find_tagged_with(*args)
+            find_options_for_tagged_with(*args)
           }
         end
       end
@@ -34,102 +42,17 @@ module HasMachineTags
       end
     end
   end
-  
-  module SingletonMethods
-    # Takes a string of delimited tags or an array of tags.
-    # 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 (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 'gem'
-    #   
-    #  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.
-    #
-    def find_tagged_with(*args)
-      options = find_options_for_find_tagged_with(*args)
-      options.blank? ? [] : find(:all,options)
-    end
     
-    def find_options_for_find_tagged_with(tags, options = {}) #:nodoc:
-      # options.reverse_merge!(:match_all=>true)
-      tags = TagList.new(tags)
-      return {} if tags.empty?
-
-      conditions = []
-      conditions << sanitize_sql(options.delete(:conditions)) if options[:conditions]
-      
-      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
-        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 ")
-            "(#{string})"
-          else
-            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) = "
-          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
-      
-      { :select => "DISTINCT #{table_name}.*",
-        :joins => "LEFT OUTER JOIN #{Tagging.table_name} #{taggings_alias} ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key} AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)} " +
-                  "LEFT OUTER JOIN #{Tag.table_name} #{tags_alias} ON #{tags_alias}.id = #{taggings_alias}.tag_id",
-        :conditions => conditions.join(" AND "),
-        :group      => group
-      }.update(options)
-    end
-  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)
+    # Set tag list with an array of tags or comma delimited string of tags.
+    def tag_list=(list)
+      @tag_list = current_tag_list(list)
     end
     
-    # Set tag list with an array of tags or comma delimited string of tags
-    def tag_list=(list)
-      @tag_list = quick_mode ? quick_mode_tag_list(list) : TagList.new(list)
+    def current_tag_list(list) #:nodoc:
+      TagList.new(list, :quick_mode=>self.quick_mode)
     end
-
+    
     # Fetches latest tag list for an object
     def tag_list
       @tag_list ||= self.tags.map(&:name)

data/rails/init.rb

@@ -0,0 +1,13 @@
+require 'has_machine_tags'
+require 'has_machine_tags/tag_methods'
+
+#attempt to load constant
+::Tag rescue nil
+if Object.const_defined? :Tag
+  ::Tag.class_eval %[include HasMachineTags::TagMethods]
+else
+  require 'has_machine_tags/tag'
+end
+
+require 'has_machine_tags/tagging'
+ActiveRecord::Base.send :include, HasMachineTags

data/test/has_machine_tags_test.rb

@@ -22,6 +22,22 @@ class HasMachineTagsTest < Test::Unit::TestCase
       @taggable.tag_list.should == arr
       @taggable.tag_list.to_s.should == arr.join(", ")
     end
+    
+    context "with quick_mode" do
+      before(:all) { TaggableModel.quick_mode = true }
+      after(:all) { TaggableModel.quick_mode = false }
+      
+      test "sets tag list normally with non quick_mode characters" do
+        arr = ['more', 'tag:type=dumb', 'really']
+        @taggable.tag_list = "more,tag:type=dumb,   really"
+        @taggable.tag_list.should == arr
+      end
+      
+      test "sets default predicate and infers namespace" do
+        @taggable.tag_list = "gem:irb;name=utility_belt, article"
+        @taggable.tag_list.should == ["gem:tags=irb", "gem:name=utility_belt", "article"]
+      end
+    end
   end
   
   context "HasMachineTags" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cldwalker-has_machine_tags
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Gabriel Horner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-20 00:00:00 -08:00
+date: 2009-02-23 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -28,14 +28,17 @@ files:
 - init.rb
 - Rakefile
 - VERSION.yml
+- rails/init.rb
 - 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/console.rb
+- lib/has_machine_tags/singleton_methods.rb
 - lib/has_machine_tags/tag.rb
 - lib/has_machine_tags/tag_list.rb
+- lib/has_machine_tags/tag_methods.rb
 - lib/has_machine_tags/tagging.rb
 - lib/has_machine_tags.rb
 - test/has_machine_tags_test.rb

data/lib/has_machine_tags/namespace_group.rb

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