cldwalker-has_machine_tags 0.1.4 → 0.1.5

data/README.rdoc

@@ -127,11 +127,14 @@ these characters are off limit unless used in the machine tag context:
 
 == Todo
 
-* More tests!
-* Console methods for showing relations between namespaces, predicates + values
-* Add support for DataMapper to be more ORM-agnostic
+* Add a match_all option to tagged_with().
+* More helper methods ie for showing relations between namespaces, predicates + values
+* Possible add support for other ORM's ie DataMapper.
 * Play friendly with other tagging plugins as needed.
 
+== Bugs
+Please report them here: http://cldwalker.lighthouseapp.com/projects/27818-has_machine_tags/tickets.
+
 == Credits
 
 Thanks goes to Flickr for popularizing this tagging model.

data/VERSION.yml

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

data/lib/has_machine_tags.rb

@@ -1,6 +1,6 @@
 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/finder'
 require 'has_machine_tags/tag_list'
 require 'has_machine_tags/console'
 
@@ -23,7 +23,7 @@ module HasMachineTags
         after_save :save_tags
         
         include HasMachineTags::InstanceMethods
-        extend HasMachineTags::SingletonMethods
+        extend HasMachineTags::Finder
         if options[:console]
           include HasMachineTags::Console::InstanceMethods
           extend HasMachineTags::Console::ClassMethods
@@ -55,9 +55,13 @@ module HasMachineTags
     
     # Fetches latest tag list for an object
     def tag_list
-      @tag_list ||= self.tags.map(&:name)
+      @tag_list ||= TagList.new(self.tags.map(&:name))
     end
-
+    
+    def quick_mode_tag_list
+      tag_list.to_quick_mode_string
+    end
+    
     protected
     # :stopdoc:
     def save_tags

data/lib/has_machine_tags/{singleton_methods.rb → finder.rb}

@@ -1,5 +1,5 @@
 module HasMachineTags
-  module SingletonMethods
+  module Finder
     # Takes a string of delimited tags or an array of tags.
     # Note that each tag is interpreted as a possible wildcard machine tag.
     # 

data/lib/has_machine_tags/tag.rb

@@ -1,3 +1,3 @@
-class ::Tag < ActiveRecord::Base
+class ::Tag < ActiveRecord::Base #:nodoc:
   include HasMachineTags::TagMethods
 end

data/lib/has_machine_tags/tag_console.rb

@@ -0,0 +1,32 @@
+module HasMachineTags
+  module TagConsole #:nodoc:
+    def self.included(base)
+      base.class_eval %[
+        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
+    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
+    end
+  end
+end

data/lib/has_machine_tags/tag_list.rb

@@ -24,7 +24,7 @@ module HasMachineTags
       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)
@@ -38,7 +38,29 @@ module HasMachineTags
         end
       }.flatten
     end
-  
+
+    def namespace_hashes #:nodoc:
+      self.inject({}) {|h, e|
+        namespace, *predicate_value = Tag.split_machine_tag(e)
+        (h[namespace] ||= []) << predicate_value unless namespace.nil?
+        h
+      }
+    end
+
+    def non_machine_tags
+      self.reject {|e| Tag.machine_tag?(e)}
+    end
+
+    # Converts tag_list to a stringified version of quick_mode.
+    def to_quick_mode_string
+      machine_tags = namespace_hashes.map {|namespace, predicate_values|
+        "#{namespace}:" + predicate_values.map {|pred, value|
+          pred == self.default_predicate ? value : "#{pred}#{Tag::VALUE_DELIMITER}#{value}"
+        }.join(QUICK_MODE_DELIMITER)
+      }
+      (machine_tags + non_machine_tags).join("#{delimiter} ")
+    end
+
     def to_s #:nodoc:
       join("#{delimiter} ")
     end

data/lib/has_machine_tags/tag_methods.rb

@@ -8,7 +8,7 @@ module HasMachineTags
 # 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.
+# Wildcard machine tag syntax is used with Tag.machine_tags() and {tagged_with() or find_tagged_with()}[link:classes/HasMachineTags/Finder.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.
@@ -82,34 +82,12 @@ module HasMachineTags
   
         #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))
@@ -126,7 +104,21 @@ module HasMachineTags
       def build_machine_tag(namespace, predicate, value)
         "#{namespace}:#{predicate}=#{value}"
       end
-  
+      
+      # Returns an array of machine tag parts: [namespace, predicate, value]
+      def split_machine_tag(machine_tag)
+        extract_from_name(machine_tag) || []
+      end
+      
+      # Boolean indicating if given tag is a machine tag.
+      def machine_tag?(machine_tag)
+        !extract_from_name(machine_tag).nil?
+      end
+      
+      def extract_from_name(tag_name) #:nodoc:
+        (tag_name =~ /^(#{NAMESPACE_REGEX})\:(#{PREDICATE_REGEX})\=(#{VALUE_REGEX})$/) ? [$1, $2, $3] : nil
+      end
+
       # Valid wildcards with their equivalent shortcuts
       # namespace:*=* -> namespace:
       # *:predicate=* -> predicate=
@@ -149,14 +141,10 @@ module HasMachineTags
     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))
+        if self.changed.include?('name') && (arr = self.class.extract_from_name(self.name))
           self[:namespace], self[:predicate], self[:value] = arr
         end
       end

data/lib/has_machine_tags/tagging.rb

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

data/test/finder_test.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class HasMachineTags::FinderTest < Test::Unit::TestCase
+  before(:each) { 
+    [Tag, Tagging, TaggableModel].each {|e| e.delete_all}
+  }
+  
+  def create_extra_taggable
+    TaggableModel.create(:tag_list=>"blah:blih=bluh")
+  end
+  
+  context "TaggableModel" do
+    context "finds by" do
+      before(:each) { 
+        @taggable = TaggableModel.create(:tag_list=>"url:lang=ruby")
+        create_extra_taggable
+      }
+    
+      test "namespace wildcard machine tag" do
+        TaggableModel.tagged_with("url:").should == [@taggable]
+      end
+    
+      test "predicate wildcard machine tag" do
+        TaggableModel.tagged_with("lang=").should == [@taggable]
+      end
+    
+      test "value wildcard machine tag" do
+        TaggableModel.tagged_with("=ruby").should == [@taggable]
+      end
+    
+      test "namespace-value wildcard machine tag" do
+        TaggableModel.tagged_with("url.ruby").should == [@taggable]
+      end
+      
+      test "predicate-value wildcard machine tag" do
+        TaggableModel.tagged_with("lang=ruby").should == [@taggable]
+      end
+    end
+    
+    context "finds with" do
+      test "multiple machine tags as an array" do
+        @taggable = TaggableModel.create(:tag_list=>"article:todo=later")
+        @taggable2 = TaggableModel.create(:tag_list=>"article:tags=funny")
+        create_extra_taggable
+        results = TaggableModel.tagged_with(["article:todo=later", "article:tags=funny"])
+        results.size.should == 2
+        results.include?(@taggable).should be(true)
+        results.include?(@taggable2).should be(true)
+      end
+      
+      test "multiple machine tags as a delimited string" do
+        @taggable = TaggableModel.create(:tag_list=>"article:todo=later")
+        @taggable2 = TaggableModel.create(:tag_list=>"article:tags=funny")
+        create_extra_taggable
+        results = TaggableModel.tagged_with("article:todo=later, article:tags=funny")
+        results.size.should == 2
+        results.include?(@taggable).should be(true)
+        results.include?(@taggable2).should be(true)
+      end
+      
+      test "condition option" do
+        @taggable = TaggableModel.create(:title=>"so limiting", :tag_list=>"url:tags=funny" )
+        create_extra_taggable
+        TaggableModel.tagged_with("url:tags=funny", :conditions=>"title = 'so limiting'").should == [@taggable]
+      end
+    end
+
+    context "when queried with normal tag" do
+      before(:each) { @taggable = TaggableModel.new }
+      test "doesn't find if machine tagged" do
+        @taggable.tag_list = 'url:tags=square'
+        @taggable.save
+        Tag.count.should == 1
+        TaggableModel.tagged_with("square").should == []
+      end
+    
+      test "finds if tagged normally" do
+        @taggable.tag_list = 'square, some:machine=tag'
+        @taggable.save
+        TaggableModel.tagged_with("square").should == [@taggable]
+      end
+    end        
+  end  
+end

data/test/has_machine_tags_test.rb

@@ -40,7 +40,7 @@ class HasMachineTagsTest < Test::Unit::TestCase
     end
   end
   
-  context "HasMachineTags" do
+  context "InstanceMethods" do
     before(:each) { @taggable = TaggableModel.new }
   
     test "creates all tags" do

data/test/{tag_test.rb → tag_methods_test.rb}

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class HasMachineTags::TagTest < Test::Unit::TestCase
+class HasMachineTags::TagMethodsTest < Test::Unit::TestCase
   test "create with normal tag name only touches name" do
     obj = Tag.create(:name=>'blah1')
     [:name, :namespace, :predicate, :value].map {|e| obj.send(e)}.should == ['blah1', nil, nil, nil]

data/test/test_helper.rb

@@ -8,6 +8,7 @@ require File.join(File.dirname(__FILE__), '..', 'init')
 
 #Setup logger
 require 'logger'
+# ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "test.log"))
 ActiveRecord::Base.logger = Logger.new(STDERR)
 ActiveRecord::Base.logger.level = Logger::WARN
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cldwalker-has_machine_tags
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Gabriel Horner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-23 00:00:00 -08:00
+date: 2009-03-22 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -35,21 +35,24 @@ files:
 - generators/has_machine_tags_migration/templates/migration.rb
 - lib/has_machine_tags
 - lib/has_machine_tags/console.rb
-- lib/has_machine_tags/singleton_methods.rb
+- lib/has_machine_tags/finder.rb
 - lib/has_machine_tags/tag.rb
+- lib/has_machine_tags/tag_console.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/finder_test.rb
 - test/has_machine_tags_test.rb
 - test/schema.rb
-- test/tag_test.rb
+- test/tag_methods_test.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/cldwalker/has_machine_tags
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement