tire 0.1.9 → 0.1.10

data/lib/tire.rb

@@ -21,6 +21,7 @@ require 'tire/index'
 require 'tire/dsl'
 require 'tire/model/naming'
 require 'tire/model/callbacks'
+require 'tire/model/percolate'
 require 'tire/model/search'
 require 'tire/model/indexing'
 require 'tire/model/import'

data/lib/tire/index.rb

@@ -44,14 +44,14 @@ module Tire
       # TODO: Infer type from the document (hash property, method)
       # TODO: Refactor common logic for getting id, JSON, into private methods
 
-      if args.size > 1
-        (type, document = args)
-      else
-        (document = args.pop; type = :document)
+      case args.size
+        when 3 then (type, document, options = args)
+        when 2 then (type, document = args)
+        else        (document = args.pop; type = :document)
       end
 
-      if document.is_a?(Hash)
-        percolate = document.delete(:percolate)
+      if options
+        percolate = options[:percolate]
         percolate = "*" if percolate === true
       end
 
@@ -222,7 +222,17 @@ module Tire
       rescue Exception => error
         raise
       ensure
-        curl = %Q|curl -X POST "#{Configuration.url}/_percolator/#{@name}/"|
+        curl = %Q|curl -X PUT "#{Configuration.url}/_percolator/#{@name}/?pretty=1" -d '#{MultiJson.encode(options)}'|
+        logged(error, '_percolator', curl)
+    end
+
+    def unregister_percolator_query(name)
+      @response = Configuration.client.delete "#{Configuration.url}/_percolator/#{@name}/#{name}"
+      MultiJson.decode(@response.body)['ok']
+      rescue Exception => error
+        raise
+      ensure
+        curl = %Q|curl -X DELETE "#{Configuration.url}/_percolator/#{@name}"|
         logged(error, '_percolator', curl)
     end
 
@@ -246,13 +256,13 @@ module Tire
       payload = { :doc => document }
       payload.update( :query => query ) if query
 
-      @response = Configuration.client.get "#{Configuration.url}/#{@name}/#{type}/_percolate", payload.to_json
+      @response = Configuration.client.get "#{Configuration.url}/#{@name}/#{type}/_percolate", MultiJson.encode(payload)
       MultiJson.decode(@response.body)['matches']
 
       rescue Exception => error
         # raise
       ensure
-        curl = %Q|curl -X POST "#{Configuration.url}/#{@name}/#{type}/_percolate"|
+        curl = %Q|curl -X GET "#{Configuration.url}/#{@name}/#{type}/_percolate?pretty=1" -d '#{payload.to_json}'|
         logged(error, '_percolate', curl)
     end
 

data/lib/tire/model/percolate.rb

@@ -0,0 +1,40 @@
+module Tire
+  module Model
+
+    module Percolate
+
+      module ClassMethods
+        def percolate!(pattern=true)
+          @@_percolator = pattern
+          self
+        end
+
+        def on_percolate(pattern=true,&block)
+          self.percolate!(pattern)
+          after_update_elastic_search_index(block)
+        end
+
+        def percolator
+          defined?(@@_percolator) ? @@_percolator : nil
+        end
+      end
+
+      module InstanceMethods
+
+        def percolate(&block)
+          index.percolate document_type, self, block
+        end
+
+        def percolate=(pattern)
+          @_percolator = pattern
+        end
+
+        def percolator
+          @_percolator || self.class.percolator || nil
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/model/search.rb

@@ -11,6 +11,9 @@ module Tire
           extend  Tire::Model::Indexing::ClassMethods
           extend  Tire::Model::Import::ClassMethods
 
+          extend  Tire::Model::Percolate::ClassMethods
+          include Tire::Model::Percolate::InstanceMethods
+
           extend  ClassMethods
           include InstanceMethods
 
@@ -81,7 +84,7 @@ module Tire
             if destroyed?
               index.remove document_type, self
             else
-              response  = index.store  document_type, self
+              response  = index.store( document_type, self, {:percolate => self.percolator} )
               self.id ||= response['_id'] if self.respond_to?(:id=)
               self.matches = response['matches']
               self
@@ -89,14 +92,17 @@ module Tire
           end
         end
 
+        def to_hash
+          self.serializable_hash
+        end
+
         def to_indexed_json
           if self.class.mapping.empty?
-            self.serializable_hash.
-              to_json
+            to_hash.to_json
           else
-            self.serializable_hash.
-              reject { |key, value| ! self.class.mapping.keys.map(&:to_s).include?(key.to_s) }.
-              to_json
+            to_hash.
+            reject { |key, value| ! self.class.mapping.keys.map(&:to_s).include?(key.to_s) }.
+            to_json
           end
         end
 

data/lib/tire/version.rb

@@ -1,3 +1,3 @@
 module Tire
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 end

data/test/integration/percolator_test.rb

@@ -7,16 +7,20 @@ module Tire
 
     context "Percolator" do
       setup do
+        delete_registered_queries
         @index = Tire.index('percolator-test')
         @index.create
       end
-      teardown { @index.delete }
+      teardown do
+        delete_registered_queries
+        @index.delete
+      end
 
       context "when registering a query" do
         should "register query as a Hash" do
           query = { :query => { :query_string => { :query => 'warning' } } }
           assert @index.register_percolator_query('alert', query)
-          sleep 0.1
+          Tire.index('_percolator').refresh; sleep 0.1
 
           percolator = Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
           assert percolator
@@ -24,12 +28,26 @@ module Tire
 
         should "register query as block" do
           assert @index.register_percolator_query('alert') { string 'warning' }
-          sleep 0.1
+          Tire.index('_percolator').refresh; sleep 0.1
 
           percolator = Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
           assert percolator
         end
 
+        should "unregister a query" do
+          query = { :query => { :query_string => { :query => 'warning' } } }
+          assert @index.register_percolator_query('alert', query)
+          Tire.index('_percolator').refresh; sleep 0.1
+          assert Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+
+          assert @index.unregister_percolator_query('alert')
+          Tire.index('_percolator').refresh; sleep 0.1
+
+          assert_raise(RestClient::ResourceNotFound) do
+            Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+          end
+        end
+
       end
 
       context "when percolating a document" do
@@ -37,7 +55,7 @@ module Tire
           @index.register_percolator_query('alert') { string 'warning' }
           @index.register_percolator_query('gantz') { string '"y u no match"' }
           @index.register_percolator_query('weather', :tags => ['weather']) { string 'severe' }
-          sleep 0.1
+          Tire.index('_percolator').refresh; sleep 0.1
         end
 
         should "return an empty array when no query matches" do
@@ -61,26 +79,35 @@ module Tire
           @index.register_percolator_query('alert') { string 'warning' }
           @index.register_percolator_query('gantz') { string '"y u no match"' }
           @index.register_percolator_query('weather', :tags => ['weather']) { string 'severe' }
-          sleep 0.1
+          Tire.index('_percolator').refresh; sleep 0.1
         end
 
         should "return an empty array when no query matches" do
-          response = @index.store :message => 'Situation normal', :percolate => true
+          response = @index.store :document, {:message => 'Situation normal'}, {:percolate => true}
           assert_equal [], response['matches']
         end
 
         should "return an array of matching query names" do
-          response = @index.store :message => 'Severe weather warning', :percolate => true
+          response = @index.store :document, {:message => 'Severe weather warning'}, {:percolate => true}
           assert_equal ['alert','weather'], response['matches'].sort
         end
 
         should "return an array of matching query names for specific percolated queries" do
-          response = @index.store :message => 'Severe weather warning', :percolate => 'tags:weather'
+          response = @index.store :document, {:message => 'Severe weather warning'}, {:percolate => 'tags:weather'}
           assert_equal ['weather'], response['matches']
         end
       end
 
     end
 
+    private
+
+    def delete_registered_queries
+      Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert") rescue nil
+      Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/gantz") rescue nil
+      Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/weather") rescue nil
+    end
+
   end
+
 end

data/test/unit/index_test.rb

@@ -232,14 +232,14 @@ module Tire
 
         should "serialize Hashes" do
           Configuration.client.expects(:post).with do |url, json|
-            url  == "#{Configuration.url}/_bulk"
-            json =~ /"_index":"dummy"/
-            json =~ /"_type":"document"/
-            json =~ /"_id":"1"/
-            json =~ /"_id":"2"/
-            json =~ /"id":"1"/
-            json =~ /"id":"2"/
-            json =~ /"title":"One"/
+            url  == "#{Configuration.url}/_bulk" &&
+            json =~ /"_index":"dummy"/ &&
+            json =~ /"_type":"document"/ &&
+            json =~ /"_id":"1"/ &&
+            json =~ /"_id":"2"/ &&
+            json =~ /"id":"1"/ &&
+            json =~ /"id":"2"/ &&
+            json =~ /"title":"One"/ &&
             json =~ /"title":"Two"/
           end.returns('{}')
 
@@ -249,14 +249,14 @@ module Tire
 
         should "serialize ActiveModel instances" do
           Configuration.client.expects(:post).with do |url, json|
-            url  == "#{Configuration.url}/_bulk"
-            json =~ /"_index":"active_model_articles"/
-            json =~ /"_type":"article"/
-            json =~ /"_id":"1"/
-            json =~ /"_id":"2"/
-            json =~ /"id":"1"/
-            json =~ /"id":"2"/
-            json =~ /"title":"One"/
+            url  == "#{Configuration.url}/_bulk" &&
+            json =~ /"_index":"active_model_articles"/ &&
+            json =~ /"_type":"active_model_article"/ &&
+            json =~ /"_id":"1"/ &&
+            json =~ /"_id":"2"/ &&
+            json =~ /"id":"1"/ &&
+            json =~ /"id":"2"/ &&
+            json =~ /"title":"One"/ &&
             json =~ /"title":"Two"/
           end.returns('{}')
 
@@ -397,7 +397,7 @@ module Tire
 
         should "register percolator query as a Hash" do
           query = { :query => { :query_string => { :query => 'foo' } } }
-          Configuration.client.expects(:post).with do |url, payload|
+          Configuration.client.expects(:put).with do |url, payload|
                                                payload = MultiJson.decode(payload)
                                                url == "#{Configuration.url}/_percolator/dummy/my-query" &&
                                                payload['query']['query_string']['query'] == 'foo'
@@ -414,7 +414,7 @@ module Tire
         end
 
         should "register percolator query as a block" do
-          Configuration.client.expects(:post).with do |url, payload|
+          Configuration.client.expects(:put).with do |url, payload|
                                                payload = MultiJson.decode(payload)
                                                url == "#{Configuration.url}/_percolator/dummy/my-query" &&
                                                payload['query']['query_string']['query'] == 'foo'
@@ -436,7 +436,7 @@ module Tire
           query = { :query => { :query_string => { :query => 'foo' } },
                     :tags  => ['alert'] }
 
-          Configuration.client.expects(:post).with do |url, payload|
+          Configuration.client.expects(:put).with do |url, payload|
                                                payload = MultiJson.decode(payload)
                                                url == "#{Configuration.url}/_percolator/dummy/my-query" &&
                                                payload['query']['query_string']['query'] == 'foo'
@@ -453,8 +453,14 @@ module Tire
           assert @index.register_percolator_query('my-query', query)
         end
 
+        should "unregister percolator query" do
+          Configuration.client.expects(:delete).with("#{Configuration.url}/_percolator/dummy/my-query").
+                               returns(mock_response('{"ok":true,"acknowledged":true}'))
+          assert @index.unregister_percolator_query('my-query')
+        end
+
         should "percolate document against all registered queries" do
-          Configuration.client.expects(:post).with do |url,payload|
+          Configuration.client.expects(:get).with do |url,payload|
                                                payload = MultiJson.decode(payload)
                                                url == "#{Configuration.url}/dummy/document/_percolate" &&
                                                payload['doc']['title'] == 'Test'
@@ -466,7 +472,7 @@ module Tire
         end
 
         should "percolate a typed document against all registered queries" do
-          Configuration.client.expects(:post).with do |url,payload|
+          Configuration.client.expects(:get).with do |url,payload|
                                                payload = MultiJson.decode(payload)
                                                url == "#{Configuration.url}/dummy/article/_percolate" &&
                                                payload['doc']['title'] == 'Test'
@@ -478,7 +484,7 @@ module Tire
         end
 
         should "percolate document against specific queries" do
-          Configuration.client.expects(:post).with do |url,payload|
+          Configuration.client.expects(:get).with do |url,payload|
                                                payload = MultiJson.decode(payload)
                                                # p [url, payload]
                                                url == "#{Configuration.url}/dummy/document/_percolate" &&
@@ -491,18 +497,18 @@ module Tire
           assert_equal ["alerts"], matches
         end
 
-        context "when storing document" do
+        context "while storing document" do
 
           should "percolate document against all registered queries" do
             Configuration.client.expects(:post).with("#{Configuration.url}/dummy/article/?percolate=*", '{"title":"Test"}').
                                  returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
-            @index.store :article, :title => 'Test', :percolate => true
+            @index.store :article, {:title => 'Test'}, {:percolate => true}
           end
 
           should "percolate document against specific queries" do
             Configuration.client.expects(:post).with("#{Configuration.url}/dummy/article/?percolate=tag:alerts", '{"title":"Test"}').
                                  returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
-            response = @index.store :article, :title => 'Test', :percolate => 'tag:alerts'
+            response = @index.store :article, {:title => 'Test'}, {:percolate => 'tag:alerts'}
             assert_equal response['matches'], ['alerts']
           end
 

data/test/unit/model_search_test.rb

@@ -307,6 +307,10 @@ module Tire
         context "serialization" do
           setup { Tire::Index.any_instance.stubs(:create).returns(true) }
 
+          should "have to_hash" do
+            assert_equal( {'title' => 'Test'}, ActiveModelArticle.new( 'title' => 'Test' ).to_hash )
+          end
+
           should "serialize itself into JSON without 'root'" do
             @model = ActiveModelArticle.new 'title' => 'Test'
             assert_equal({'title' => 'Test'}.to_json, @model.to_indexed_json)
@@ -372,6 +376,121 @@ module Tire
 
         end
 
+        context "with percolation" do
+          setup do
+            class ::ActiveModelArticleWithCallbacks; percolate!(false); end
+            @article = ::ActiveModelArticleWithCallbacks.new :title => 'Test'
+          end
+
+          should "return matching queries on percolate" do
+            Tire::Index.any_instance.expects(:percolate).returns(["alert"])
+
+            assert_equal ['alert'], @article.percolate
+          end
+
+          should "pass the arguments to percolate" do
+            filter   = lambda { string 'tag:alerts' }
+
+            Tire::Index.any_instance.expects(:percolate).with do |type,doc,query|
+              # p [type,doc,query]
+              type  == 'active_model_article_with_callbacks' &&
+              doc   == @article &&
+              query == filter
+            end.returns(["alert"])
+
+            assert_equal ['alert'], @article.percolate(&filter)
+          end
+
+          should "mark the instance for percolation on index update" do
+            @article.percolate = true
+
+            Tire::Index.any_instance.expects(:store).with do |type,doc,options|
+              # p [type,doc,options]
+              options[:percolate] == true
+            end.returns(MultiJson.decode('{"ok":true,"_id":"test","matches":["alerts"]}'))
+
+            @article.update_elastic_search_index
+          end
+
+          should "not percolate document on index update when not set for percolation" do
+            Tire::Index.any_instance.expects(:store).with do |type,doc,options|
+              # p [type,doc,options]
+              options[:percolate] == nil
+            end.returns(MultiJson.decode('{"ok":true,"_id":"test"}'))
+
+            @article.update_elastic_search_index
+          end
+
+          should "set the default percolator pattern" do
+            class ::ActiveModelArticleWithPercolation < ::ActiveModelArticleWithCallbacks
+              percolate!
+            end
+
+            assert_equal true, ::ActiveModelArticleWithCallbacks.percolator
+          end
+
+          should "set the percolator pattern" do
+            class ::ActiveModelArticleWithPercolation < ::ActiveModelArticleWithCallbacks
+              percolate! 'tags:alert'
+            end
+
+            assert_equal 'tags:alert', ::ActiveModelArticleWithCallbacks.percolator
+          end
+
+          should "mark the class for percolation on index update" do
+            class ::ActiveModelArticleWithPercolation < ::ActiveModelArticleWithCallbacks
+              percolate!
+            end
+
+            Tire::Index.any_instance.expects(:store).with do |type,doc,options|
+              # p [type,doc,options]
+              options[:percolate] == true
+            end.returns(MultiJson.decode('{"ok":true,"_id":"test","matches":["alerts"]}'))
+
+            percolated = ActiveModelArticleWithPercolation.new :title => 'Percolate me!'
+            percolated.update_elastic_search_index
+          end
+
+          should "execute the 'on_percolate' callback" do
+            $test__matches = nil
+            class ::ActiveModelArticleWithPercolation < ::ActiveModelArticleWithCallbacks
+              on_percolate { $test__matches = matches }
+            end
+            percolated = ActiveModelArticleWithPercolation.new :title => 'Percolate me!'
+
+            Tire::Index.any_instance.expects(:store).
+                                     with do |type,doc,options|
+                                       doc == percolated &&
+                                       options[:percolate] == true
+                                     end.
+                                     returns(MultiJson.decode('{"ok":true,"_id":"test","matches":["alerts"]}'))
+
+            percolated.update_elastic_search_index
+
+            assert_equal ['alerts'], $test__matches
+          end
+
+          should "execute the 'on_percolate' callback for specific pattern" do
+            $test__matches = nil
+            class ::ActiveModelArticleWithPercolation < ::ActiveModelArticleWithCallbacks
+              on_percolate('tags:alert') { $test__matches = self.matches }
+            end
+            percolated = ActiveModelArticleWithPercolation.new :title => 'Percolate me!'
+
+            Tire::Index.any_instance.expects(:store).
+                                     with do |type,doc,options|
+                                       doc == percolated &&
+                                       options[:percolate] == 'tags:alert'
+                                     end.
+                                     returns(MultiJson.decode('{"ok":true,"_id":"test","matches":["alerts"]}'))
+
+            percolated.update_elastic_search_index
+
+            assert_equal ['alerts'], $test__matches
+          end
+
+        end
+
       end
 
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tire
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 1
-  - 9
-  version: 0.1.9
+  - 10
+  version: 0.1.10
 platform: ruby
 authors: 
 - Karel Minarik
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-13 00:00:00 +02:00
+date: 2011-06-14 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -269,6 +269,7 @@ files:
 - lib/tire/model/import.rb
 - lib/tire/model/indexing.rb
 - lib/tire/model/naming.rb
+- lib/tire/model/percolate.rb
 - lib/tire/model/persistence.rb
 - lib/tire/model/persistence/attributes.rb
 - lib/tire/model/persistence/finders.rb