rocket_tag 0.5.0 → 0.5.1

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.5.1

data/lib/rocket_tag/tag.rb

@@ -5,5 +5,11 @@ module RocketTag
 
     validates_presence_of :name
     validates_uniqueness_of :name
+
+    def self.by_taggable_type(type)
+      joins{taggings}.where{taggings.taggable_type == type.to_s}
+    end
+
+
   end
 end

data/lib/rocket_tag/taggable.rb

@@ -1,4 +1,40 @@
 require 'squeel'
+module Squeel
+  module Adapters
+    module ActiveRecord
+      module RelationExtensions
+
+        # The purpose of this call is to close a query and make
+        # it behave as a simple table or view. If a query has
+        # aggregate functions applied then downstream active
+        # relation chaining causes unpredictable behaviour.
+        #
+        # This call isolates the group by behaviours.
+        def isolate_group_by_as(type)
+          type.from("(#{to_sql}) #{type.table_name}")
+        end
+
+        def select_all
+          select('*')
+        end
+
+        # We really only want to group on id for practical
+        # purposes but POSTGRES requires that a group by outputs
+        # all the column names not under an aggregate function.
+        #
+        # This little helper generates such a group by
+        def group_by_all_columns
+          cn = self.column_names
+          group { cn.map { |col| __send__(col) } }
+        end
+
+        def exists
+        end
+ 
+      end
+    end
+  end
+end
 
 module RocketTag
   module Taggable
@@ -81,6 +117,7 @@ module RocketTag
         @contexts[context.to_sym] || []
       end
 
+
       def tagged_similar options = {}
         context = options.delete :on
         if context
@@ -111,14 +148,13 @@ module RocketTag
           s | t
         end
 
-        inner = self.class.select{count(~id).as(tags_count)}.
-        select("#{self.class.table_name}.*").
-        joins{tags}.where{condition}.
-        group(self.class.column_names.map{|col| "#{self.class.table_name}.#{col}"}).
-        where{~id != my{id}}.
-        order("tags_count DESC")
+        r = self.class.
+          joins{tags}.
+          where{condition}.
+          where{~id != my{id}}
+
+        self.class.count_tags(r)
 
-        r = self.class.from("(#{inner.to_sql}) #{self.class.table_name}")
       end
     end
 
@@ -128,9 +164,44 @@ module RocketTag
         @rocket_tag ||= RocketTag::Taggable::Manager.new(self)
       end
 
-      def _with_tag_context context
+      # Provides the tag counting functionality by adding an
+      # aggregate count on id. Assumes valid a join has been
+      # made.
+      def count_tags(rel)
+        rel.select_all.
+        select{count(~id).as(tags_count)}.
+        group_by_all_columns.
+        order("tags_count DESC").
+        isolate_group_by_as(self)
+      end
+
+      # Filters tags according to
+      # context. context param can
+      # be either a single context
+      # id or an array of context ids
+      def with_tag_context context
         if context
-          where{taggings.context == context.to_s}
+          if context
+            if context.class == Array
+              contexts = context
+            else
+              contexts = [context]
+            end
+          else
+            contexts = []
+          end
+
+          conditions = contexts.map do |context|
+            squeel do
+              (taggings.context == context.to_s)
+            end
+          end
+
+          condition = conditions.inject do |s, t|
+            s | t
+          end
+
+          where{condition}
         else
           where{ }
         end
@@ -151,25 +222,17 @@ module RocketTag
       # Generates a query that provides the matches
       # along with an extra column :tags_count.
       def tagged_with tags_list, options = {}
-        on = options.delete :on
 
-        inner = select{count(~id).as(tags_count)}.
-            select("#{self.table_name}.*").
-            joins{tags}.
+        r = joins{tags}.
             where{tags.name.in(tags_list)}.
-            _with_tag_context(on).
-            group(self.column_names.map{|col| "#{self.table_name}.#{col}"})
+            with_tag_context(options.delete :on)
 
-        # Wrap the inner query with an outer query to shield
-        # the group and aggregate clauses from downstream
-        # queries
-        r = from("(#{inner.to_sql}) #{table_name}")
+
+        r = count_tags(r)
 
         if options.delete :all
           r = r.where{tags_count==tags_list.length}
-        end
-
-        if min = options.delete(:min)
+        elsif min = options.delete(:min)
           r = r.where{tags_count>=min}
         end
 
@@ -178,7 +241,7 @@ module RocketTag
             id.in(r.select{"id"})
           end
         else
-          r.select("*")
+          r
         end
 
       end
@@ -186,45 +249,20 @@ module RocketTag
       # Generates a query that returns list of popular tags
       # for given model with an extra column :tags_count.
       def popular_tags options={}
-        context = options.delete :on
-        if context
-          if context.class == Array
-            contexts = context
-          else
-            contexts = [context]
-          end
-        else
-          contexts = []
-        end
 
-        conditions = contexts.map do |context|
-          squeel do
-            (taggings.context == context.to_s)
-          end
-        end
+        r = 
+            RocketTag::Tag.
+            joins{taggings}.
+            with_tag_context(options.delete :on).
+            by_taggable_type(self)
 
-        condition = conditions.inject do |s, t|
-          s | t
-        end
-        inner = RocketTag::Tag.select{count(~id).as(tags_count)}.
-            select("#{RocketTag::Tag.table_name}.*").
-            joins{taggings.outer}.where{condition}.
-            where{ taggings.taggable_type == my{self.to_s} }.
-            group{~id} #.
-            #order("tags_count DESC")
-        r = from("(#{inner.to_sql}) #{table_name}")
+        r = count_tags(r)
 
         if min = options.delete(:min)
           r = r.where{tags_count>=min}
         end
 
-        if options.delete :sifter
-          squeel do
-            id.in(r.select{"id"})
-          end
-        else
-          r.select("*")
-        end
+        r
       end
 
       def setup_for_rocket_tag
@@ -261,7 +299,10 @@ module RocketTag
                 tags_to_assign = exisiting_tags + created_tags
 
                 tags_to_assign.each do |tag|
-                  tagging = Tagging.new :tag => tag, :taggable => self, :context => context, :tagger => nil
+                  tagging = Tagging.new :tag => tag, 
+                    :taggable => self, 
+                    :context => context, 
+                    :tagger => nil
                   self.taggings << tagging
                 end
               end

data/rocket_tag.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "rocket_tag"
-  s.version = "0.5.0"
+  s.version = "0.5.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brad Phelan"]
-  s.date = "2012-06-26"
+  s.date = "2012-06-29"
   s.description = ""
   s.email = "bradphelan@xtargets.com"
   s.extra_rdoc_files = [

data/spec/rocket_tag/taggable_spec.rb

@@ -306,18 +306,16 @@ describe TaggableModel do
         end
       end
 
-      describe "#tagged_with_sifter" do
-        it "should be the work horse of #tagged_with but returns a sifter that can be composed into other queries" 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
-            TaggableModel.tagged_with_sifter(["a", "b"]) & TaggableModel.tagged_with_sifter(["c"])
+            id.in(TaggableModel.tagged_with(["a", "b"]).select{id}) & 
+            id.in(TaggableModel.tagged_with(["c"]).select{id})
           end.count.should == 2
 
-          x = TaggableModel.where do
-            TaggableModel.tagged_with_sifter(["a", "b"]) & TaggableModel.tagged_with_sifter(["c"])
-          end.to_sql
-
           TaggableModel.where do
-            TaggableModel.tagged_with_sifter(["a", "b"])
+            id.in(TaggableModel.tagged_with(["a", "b"]).select{id})
           end.count.should == 4
         end
 

metadata

@@ -2,7 +2,7 @@
 name: rocket_tag
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors: 
 - Brad Phelan
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-06-26 00:00:00 Z
+date: 2012-06-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -144,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -285597818413014276
+      hash: 88231840862745454
       segments: 
       - 0
       version: "0"