rocket_tag 0.5.3 → 0.5.4

data/README.md

@@ -52,6 +52,10 @@ Match all tags on a specific context
 Match a miniumum number of tags
 
     TaggableModel.tagged_with ["math", "kiting", "coding", "sleeping"], :min => 2, :on => "skills"
+
+Match tags to specific contexts
+
+    TaggableModel.tagged_with { :skills => ["math", "kiting"], :languages => ["english", "german"]
 	
 Take advantage of the tags_count synthetic column returned with every query
 
@@ -61,6 +65,21 @@ Mix with active relation
 
     TaggableModel.tagged_with(["forking", "kiting"]).where( ["created_at > ?", Time.zone.now.ago(5.hours)])  
 
+or even downstream
+
+    User.where{email="bradphelan@xtargets.com"}.documents.tagged_with ['kiting', 'math'] , :on => :skills
+
+where we might have
+
+    class User < ActiveRecord::Base
+      has_many :documents
+    end
+
+    class Document < ActiveRecord::Base
+      belongs_to :user
+      attr_taggable :tags
+    end 
+
 Find similar models based on tags on a specific context and return in decending order
 of 'tags_count'
 
@@ -79,30 +98,24 @@ of 'tags_count'. Note that each tag is still scoped according to it's context
 
     model.tagged_similar  
 
-For reference the SQL generated for model.tagged_similar when there are
-context [:skills, :languages] available is
-
-      SELECT "taggable_models".* FROM   
-            (
-              SELECT COUNT("taggable_models"."id") AS tags_count, 
-                     taggable_models.* 
-              FROM   "taggable_models" 
-                     INNER JOIN "taggings" 
-                       ON "taggings"."taggable_id" = "taggable_models"."id" 
-                          AND "taggings"."taggable_type" = 'TaggableModel' 
-                     INNER JOIN "tags" 
-                       ON "tags"."id" = "taggings"."tag_id" 
-              WHERE  "taggable_models"."id" != 2 
-                     AND ((   ( "tags"."name" IN ( 'german', 'french' ) AND "taggings"."context" = 'languages' ) 
-                           OR ( "tags"."name" IN ( 'a', 'b', 'x' )      AND "taggings"."context" = 'skills' ) 
-                         )) 
-              GROUP  BY "taggable_models"."id" 
-              ORDER  BY tags_count DESC
-            ) taggable_models 
-
-
-Note the aliasing of the inner select to shield the GROUP BY from downstream active relation
-queries
+Find popular tags and generate tags clouds for specific scopes
+
+    User.where{email="bradphelan@xtargets.com"}.documents.popular_tags
+
+where we might have
+
+    class User < ActiveRecord::Base
+      has_many :documents
+    end
+
+    class Document < ActiveRecord::Base
+      belongs_to :user
+      attr_taggable :tags
+    end 
+
+and you can access the field *tags_count* on each Tag instance returned
+by the above query. Generating the CSS and html for your tag cloud
+is outside the scope of this project but it should be easy to do.
 
 == Contributing to rocket_tag
  

data/VERSION

@@ -1 +1 @@
-0.5.3
+0.5.4

data/lib/rocket_tag/taggable.rb

@@ -24,9 +24,6 @@ module Squeel
           group { cn.map { |col| __send__(col) } }
         end
 
-        def exists
-        end
- 
       end
     end
   end
@@ -113,28 +110,21 @@ module RocketTag
         @contexts[context.to_sym] || []
       end
 
+      # Find models with similar tags to the
+      # current model ordered is decending
+      # order of the number of matches
       def tagged_similar options = {}
         context = options.delete :on
 
-        contexts = self.class.normalize_contexts(context, self.class.rocket_tag.contexts)
-
-        condition = contexts.reject do |c|
-          tags_for_context(c).size == 0
-        end.map do |context|
-          self.class.squeel do
-            tags.name.in(my{tags_for_context(context)}) & 
-              (taggings.context == context.to_s)
-          end
-        end.inject do |s, t|
-          s | t
-        end
-
-        r = self.class.
-          joins{tags}.
-          where{condition}.
-          where{~id != my{id}}
+        contexts = self.class.normalize_contexts context, 
+          self.class.rocket_tag.contexts
 
-        self.class.count_tags(r)
+        q = self.class.tagged_with Hash[*contexts.map{|c| 
+          [c, tags_for_context(c)]
+        }.flatten(1)]
+       
+        # Exclude self from the results
+        q.where{id!=my{id}}
 
       end
     end
@@ -156,7 +146,7 @@ module RocketTag
       #
       # rel can be passed as the last expression in a block
       # if desired.
-      def count_tags(rel=nil)
+      def tags_count(type=self)
         if block_given?
           rel = yield
         end
@@ -164,7 +154,7 @@ module RocketTag
         select{count(~id).as(tags_count)}.
         group_by_all_columns.
         order("tags_count DESC").
-        isolate_group_by_as(self)
+        isolate_group_by_as(type)
       end
 
       def is_valid_context? context
@@ -190,7 +180,7 @@ module RocketTag
       # Verify contexts are valid for the taggable type
       def validate_contexts contexts
         contexts.each do |context|
-          unless self.is_valid_context? context
+          unless is_valid_context? context
             raise Exception.new("#{context} is not a valid tag context for #{self}") 
           end
         end
@@ -217,54 +207,95 @@ module RocketTag
 
       end
 
+      def tagged_with tags_list, options = {}
 
-      # Generates a sifter or a where clause depending on options.
-      # The sifter generates a subselect with the body of the
-      # clause wrapped up so that it can be used as a condition
-      # within another squeel statement. 
-      #
-      # Query optimization is left up to the SQL engine.
-      def tagged_with_sifter tags_list, options = {}
-        options[:sifter] = true
-        tagged_with tags_list, options
-      end
+        # Grab table name
+        t = self.to_s
 
-      # Generates a query that provides the matches
-      # along with an extra column :tags_count.
-      def tagged_with tags_list, options = {}
+        q = joins{taggings.tag}
 
-        r = count_tags do
-          joins{tags}.
+        case tags_list
+        when Hash
+          # A tag can only match it's context
+
+          c = tags_list.each_key.map do |context|
+            squeel do
+              tags.name.in(tags_list[context]) & (taggings.context == context.to_s)
+            end
+          end.inject do |s,t|
+            s | t
+          end
+
+          q = q.where(c)
+
+        else
+          # Any tag can match any context
+          q = q.
             where{tags.name.in(tags_list)}.
             where(with_tag_context(options.delete(:on)))
         end
 
-        if options.delete :all
-          r.where{tags_count==tags_list.length}
-        elsif min = options.delete(:min)
-          r.where{tags_count>=min}
-        else
-          r
-        end
+        q = q.group_by_all_columns.
+          select{count(tags.id).as(tags_count)}.
+          select('*').
+          order("tags_count desc")
 
+        # Isolate the aggregate uery by wrapping it as
+        #
+        # select * from ( ..... ) tags
+        q = from(q.arel.as(self.table_name))
+        
+        # Restrict by minimum tag counts if required
+        min = options.delete :min 
+        q = q.where{tags_count>=min} if min 
+
+        # Require all the tags if required
+        all = options.delete :all
+        q = q.where{tags_count==tags_list.length} if all
+
+        # Return the relation
+        q
       end
 
-      # Generates a query that returns list of popular tags
-      # for given model with an extra column :tags_count.
-      def popular_tags options={}
+      # Get the tags associated with this model class
+      # This can be chained such as
+      #
+      # User.documents.tags
+      def tags(options = {})
 
-        r = count_tags do 
-          RocketTag::Tag.
-            joins{taggings}.
-            where(with_tag_context(options.delete(:on))).
-            by_taggable_type(self)
-        end
+        # Grab the current scope
+        s = select{id}
 
-        if min = options.delete(:min)
-          r = r.where{tags_count>=min}
-        end
+        # Grab table name
+        t = self.to_s
+
+        q = RocketTag::Tag.joins{taggings}.
+          where{taggings.taggable_type==t}.  # Apply taggable type
+          where{taggings.taggable_id.in(s)}. # Apply current scope
+          where(with_tag_context(options.delete(:on))). # Restrict by context
+          group_by_all_columns.
+          select{count(tags.id).as(tags_count)}.
+          select('*').
+          order("tags_count desc")
+
+        # Isolate the aggregate uery by wrapping it as
+        #
+        # select * from ( ..... ) tags
+        q = RocketTag::Tag.from(q.arel.as(RocketTag::Tag.table_name))
+        
+        # Restrict by minimum tag counts if required
+        min = options.delete :min 
+        q = q.where{tags_count>=min} if min 
 
-        r
+        # Return the relation
+        q
+
+      end
+
+      # Generates a query that returns list of popular tags
+      # for given model with an extra column :tags_count.
+      def popular_tags options={}
+        tags(options)
       end
 
       def setup_for_rocket_tag
@@ -338,21 +369,18 @@ module RocketTag
               :through => :taggings,
               :conditions => [ "taggings.context = ?", context ]
 
-
             validate context do
               if not send(context).kind_of? Enumerable
                 errors.add context, :invalid
               end
             end
 
-
             # Return an array of RocketTag::Tags for the context
             define_method "#{context}" do
               cache_tags
               tags_for_context(context)
             end
 
-
             define_method "#{context}=" do |list|
               list = Manager.parse_tags list
 
@@ -362,7 +390,6 @@ module RocketTag
 
               (@tag_dirty ||= Set.new) << context
 
-
             end
           end
         end

data/rocket_tag.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "rocket_tag"
-  s.version = "0.5.3"
+  s.version = "0.5.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brad Phelan"]

data/spec/models.rb

@@ -8,6 +8,11 @@ class TaggableModel < ActiveRecord::Base
   attr_taggable :skills
   attr_taggable :needs, :offerings
   has_many :untaggable_models
+  belongs_to :user
+end
+
+class User < ActiveRecord::Base
+  has_many :taggable_models
 end
 
 class CachedModel < ActiveRecord::Base

data/spec/rocket_tag/taggable_spec.rb

@@ -87,16 +87,19 @@ describe TaggableModel do
   describe "querying tags" do
 
     before :each do
-      @t00 = TaggableModel.create :name => "00", :foo => "A"
-      @t01 = TaggableModel.create :name => "01", :foo => "B"
+      @user0 = User.create :name => "brad"
+      @user1 = User.create :name => "hannah"
 
+      @t00 = TaggableModel.create :name => "00", :foo => "A", :user => @user0
+      @t01 = TaggableModel.create :name => "01", :foo => "B", :user => @user1
 
-      @t10 = TaggableModel.create :name => "10", :foo => "A"
-      @t11 = TaggableModel.create :name => "11", :foo => "B"
 
+      @t10 = TaggableModel.create :name => "10", :foo => "A", :user => @user0
+      @t11 = TaggableModel.create :name => "11", :foo => "B", :user => @user1
 
-      @t20 = TaggableModel.create :name => "20", :foo => "A"
-      @t21 = TaggableModel.create :name => "21", :foo => "B"
+
+      @t20 = TaggableModel.create :name => "20", :foo => "A", :user => @user0
+      @t21 = TaggableModel.create :name => "21", :foo => "B", :user => @user1
 
       @t00.skills    =  [ "a"      , "b",  "x"]
       @t00.languages =  [ "german" , "french"]
@@ -167,6 +170,14 @@ describe TaggableModel do
           r.find{|i|i.name == "11"}.tags_count.should == 1
           r.find{|i|i.name == "21"}.should be_nil
 
+          # It should be possible to narrow scopes with tagged_with
+          r = @user0.taggable_models.tagged_with(["a", "b", "german"], :on => :skills).all
+          r.find{|i|i.name == "00"}.tags_count.should == 2
+          r.find{|i|i.name == "01"}.should be_nil
+          r.find{|i|i.name == "10"}.tags_count.should == 1
+          r.find{|i|i.name == "11"}.should be_nil
+          r.find{|i|i.name == "21"}.should be_nil
+
         end
     end
 
@@ -314,10 +325,11 @@ describe TaggableModel do
       describe "Using in subqueries" do
         it "should be possible to select the 'id' of the relation to use in a subquery" do
 
-          TaggableModel.where do
+          q = TaggableModel.where do
             id.in(TaggableModel.tagged_with(["a", "b"]).select{id}) & 
             id.in(TaggableModel.tagged_with(["c"]).select{id})
-          end.count.should == 2
+          end
+          q.count.should == 2
 
           TaggableModel.where do
             id.in(TaggableModel.tagged_with(["a", "b"]).select{id})
@@ -338,6 +350,40 @@ describe TaggableModel do
           TaggableModel.popular_tags(:on=>[:skills, :languages]).order('id asc').first.name.should == 'a'
           TaggableModel.popular_tags(:on=>[:skills, :languages]).order('id asc').last.name.should == 'jinglish'
           TaggableModel.popular_tags(:min=>2).all.length.should == 6 ## dirty!
+
+
+
+        end
+      end
+
+      describe "tag cloud calculations" do
+        it "should return tags on an association and the counts thereof" do
+          @user0.taggable_models.popular_tags.each do |tag|
+            puts "#{tag.name}\t#{tag.tags_count}"
+          end
+          puts "-------------"
+          @user1.taggable_models.popular_tags.each do |tag|
+            puts "#{tag.name}\t#{tag.tags_count}"
+          end
+
+          # Check that the tags_count on each tag is in
+          # descending order.
+          @user0.taggable_models.popular_tags.count.should == 8
+          @user0.taggable_models.popular_tags.inject do |s, t|
+            s.tags_count.should >= t.tags_count
+            t
+          end
+
+          @user1.taggable_models.popular_tags.count.should == 8
+          @user1.taggable_models.popular_tags.inject do |s, t|
+            s.tags_count.should >= t.tags_count
+            t
+          end
+
+          # Sanity check the two queries are not identical
+          @user0.taggable_models.popular_tags.should_not == 
+            @user1.taggable_models.popular_tags
+
         end
       end
     end

data/spec/schema.rb

@@ -17,6 +17,7 @@ ActiveRecord::Schema.define :version => 0 do
   end
   
   create_table :taggable_models, :force => true do |t|
+    t.column :user_id, :integer
     t.column :name, :string
     t.column :type, :string
     t.column :foo,  :string
@@ -46,7 +47,7 @@ ActiveRecord::Schema.define :version => 0 do
     t.column :cached_glass_list, :string
   end
   
-  create_table :taggable_users, :force => true do |t|
+  create_table :users, :force => true do |t|
     t.column :name, :string
   end
   

metadata

@@ -2,7 +2,7 @@
 name: rocket_tag
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors: 
 - Brad Phelan
@@ -144,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 293230795738832648
+      hash: -4496343297606785835
       segments: 
       - 0
       version: "0"