rocket_tag 0.1.0 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/rocket_tag/taggable.rb

@@ -43,10 +43,6 @@ module RocketTag
       end
     end
 
-    def tags_for_context context
-      tags.where{taggings.context==my{context}}
-    end
-
     def taggings_for_context context
       taggings.where{taggings.context==my{context}}
     end
@@ -86,6 +82,20 @@ module RocketTag
       end
     end
 
+    module InstanceMethods
+      def tagged_similar options = {}
+        context = options.delete :on
+        raise Exception.new("#{context} is not a valid tag context for #{self.class}") unless self.class.rocket_tag.contexts.include? context
+        if context
+          contexts = [context]
+        else
+          contexts = self.class.rocket_tag.contexts
+        end
+        tags = send context.to_sym
+        self.class.tagged_with(tags, options).where{id != my{id}}
+      end
+    end
+
     module ClassMethods
 
       def rocket_tag
@@ -100,14 +110,6 @@ module RocketTag
         end
       end
 
-      def _with_min min, tags_list
-        if min and min > 1
-          group{~id}.
-            having{count(~id)>=my{min}}
-        else
-          where{}
-        end
-      end
 
       # Generates a sifter or a where clause depending on options.
       # The sifter generates a subselect with the body of the
@@ -116,41 +118,43 @@ module RocketTag
       #
       # 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
+
+      # Generates a query that provides the matches
+      # along with an extra column :tags_count.
+      def tagged_with tags_list, options = {}
         on = options.delete :on
-        all = options.delete :all
-        min = options.delete(:min)
-        if all
-          min = tags_list.length
-        end
 
-        lambda do |&block|
-        if options.delete :where
-          where &block
-        else
-          squeel &block
-        end
-        end.call do
-          id.in(
-            my{self}.
-            select{id}.
+        inner = select{count(~id).as(tags_count)}
+            .select("#{self.table_name}.*").
             joins{tags}.
             where{tags.name.in(my{tags_list})}.
             _with_tag_context(on).
-            _with_min(min, tags_list)
-          )
-        end
+            group{~id}
 
-      end
+        # 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}")
 
-      # We need to overide the default count
-      # and do a sub select as we are using gr
-      def count
-      end
+        if options.delete :all
+          r = r.where{tags_count==my{tags_list.length}}
+        end
 
+        if min = options.delete(:min)
+          r = r.where{tags_count>=my{min}}
+        end
+
+        if options.delete :sifter
+          squeel do
+            id.in(r.select{"id"})
+          end
+        else
+          r.select("*")
+        end
 
-      def tagged_with tags_list, options = {}
-        options[:where] = true
-        tagged_with_sifter(tags_list, options)
       end
 
       def setup_for_rocket_tag

data/rocket_tag.gemspec

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

data/spec/rocket_tag/taggable_spec.rb

@@ -121,6 +121,55 @@ describe TaggableModel do
       pending "Need to figure out how to verify eager loading other than manually inspect the log file"
     end
 
+    describe "#tagged_with" do
+        it "should count the number of matched tags" do
+
+          #<TaggableModel id: 2, name: "00", type: nil, foo: "A"> - 3 - german, french, a, b, x
+          #<TaggableModel id: 3, name: "01", type: nil, foo: "B"> - 3 - german, italian, a, b, y
+          #<TaggableModel id: 4, name: "10", type: nil, foo: "A"> - 1 - a, c
+          #<TaggableModel id: 5, name: "11", type: nil, foo: "B"> - 1 - a, c
+          #<TaggableModel id: 7, name: "21", type: nil, foo: "B"> - 1 - german, jinglish, c, d
+          
+#           r = TaggableModel.tagged_with(["a", "b", "german"]).all.each do |m|
+#             puts "#{m.inspect} - #{m.tags_count} - #{m.tags.map(&:name).join ', '}"
+#           end
+
+          r = TaggableModel.tagged_with(["a", "b", "german"]).all
+          r.find{|i|i.name == "00"}.tags_count.should == 3
+          r.find{|i|i.name == "01"}.tags_count.should == 3
+          r.find{|i|i.name == "10"}.tags_count.should == 1
+          r.find{|i|i.name == "11"}.tags_count.should == 1
+          r.find{|i|i.name == "21"}.tags_count.should == 1
+
+          # The 'group by' operation to generate the count tags should
+          # be opaque to downstream operations. Thus count should
+          # return the correct number of records
+          r = TaggableModel.tagged_with(["a", "b", "german"]).count.should == 5
+
+          # It should be possible to cascade active relation queries on
+          # the 
+          r = TaggableModel.tagged_with(["a", "b", "german"]).
+            where{tags_count>2}.count.should == 2
+
+          # The min option is a shortcut for a query on tags_count
+          r = TaggableModel.tagged_with(["a", "b", "german"], :min => 2).count.should == 2
+
+          r = TaggableModel.tagged_with(["a", "b", "german"], :on => :skills).all
+          r.find{|i|i.name == "00"}.tags_count.should == 2
+          r.find{|i|i.name == "01"}.tags_count.should == 2
+          r.find{|i|i.name == "10"}.tags_count.should == 1
+          r.find{|i|i.name == "11"}.tags_count.should == 1
+          r.find{|i|i.name == "21"}.should be_nil
+
+        end
+    end
+
+    describe "#tagged_similar" do
+      it "should work" do
+        @t00.tagged_similar(:on => :skills).count.should == 3
+      end
+    end
+
     describe "#tagged_with" do
       describe ":all => true" do
         it "should return records where *all* tags match on any context" do
@@ -176,34 +225,60 @@ describe TaggableModel do
         end
       end
 
+      describe "Experiments with AREL" do
+        it "foo" do
+          u_t = Arel::Table::new :users
+          l_t = Arel::Table::new :logs
+
+          counts = l_t.
+            group(l_t[:user_id]).
+            project(
+              l_t[:user_id].as("user_id"), 
+              l_t[:user_id].count.as("count_all")
+          ).as "foo"
+
+          puts TaggableModel.joins("JOIN " + counts.to_sql ).to_sql
+        end
+        it "should" do
+          u_t = Arel::Table::new :users
+          l_t = Arel::Table::new :logs
+	
+          counts = l_t.
+            group(l_t[:user_id]).
+            project(
+              l_t[:user_id].as("user_id"), 
+              l_t[:user_id].count.as("count_all")
+            ).as "foo"
+          
+          users = u_t.
+            join(counts).
+            on(u_t[:id].
+            eq(counts[:user_id])).
+            project("*").project(counts[:count_all])
+
+          puts users.to_sql
+          
+        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
           TaggableModel.where do
             TaggableModel.tagged_with_sifter(["a", "b"]) & TaggableModel.tagged_with_sifter(["c"])
           end.count.should == 2
 
+          x = TaggableModel.where do
+            TaggableModel.tagged_with_sifter(["a", "b"]) & TaggableModel.tagged_with_sifter(["c"])
+          end.to_sql
+          puts x
+
           TaggableModel.where do
             TaggableModel.tagged_with_sifter(["a", "b"])
           end.count.should == 4
         end
 
-        it "should have the options from #tagged_with passed through" do
-            tags_list = ["a", "b"]
-            options = {:x=>10, :y=>20}
-            TaggableModel.should_receive(:tagged_with_sifter).with(tags_list, options)
-            TaggableModel.tagged_with(tags_list, options)
-        end
       end
 
-      describe "option :min" do
-        it "should return records where the number of matching tags >= :min" do
-          TaggableModel.tagged_with(["a", "b", "x"], :on => :skills).count.should == 4
-
-          TaggableModel.tagged_with(["a", "b", "x"], :on => :skills, :min => 1).count.should == 4
-          TaggableModel.tagged_with(["a", "b", "x"], :on => :skills, :min => 2).count.should == 2
-          TaggableModel.tagged_with(["a", "b", "x"], :on => :skills, :min => 3).count.should == 1
-        end
-      end
     end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: rocket_tag
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Brad Phelan
@@ -144,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3706512005983090004
+      hash: -1107478710277863404
       segments: 
       - 0
       version: "0"