tire 0.1.8 → 0.1.9

data/examples/tire-dsl.rb

@@ -704,6 +704,103 @@ s = Tire.search 'articles' do
   highlight :title, :body, :options => { :tag => '<strong class="highlight">' }
 end
 
+#### Percolation
+
+# _ElasticSearch_ comes with one very interesting, and rather unique feature:
+# [_percolation_](http://www.elasticsearch.org/guide/reference/api/percolate.html).
+
+# It works in a „reverse search“ manner to regular search workflow of adding
+# documents to the index and then querying them.
+# Percolation allows us to register a query, and ask if a specific document
+# matches it, either on demand, or immediately as the document is being indexed.
+
+# Let's review an example for an index named _weather_.
+# We will register three queries for percolation against this index.
+#
+index = Tire.index('weather') do
+  delete
+  create
+
+  # First, a query named _warning_,
+  #
+  register_percolator_query('warning', :tags => ['warning']) { string 'warning OR severe OR extreme' }
+
+  # a query named _tsunami_,
+  #
+  register_percolator_query('tsunami', :tags => ['tsunami']) { string 'tsunami' }
+
+  # and a query named _floods_.
+  #
+  register_percolator_query('floods',  :tags => ['floods'])  { string 'flood*' }
+
+end
+
+# Notice, that we have added a _tags_ field to the query document, because it behaves
+# just like any other document in _ElasticSearch_.
+
+# We will refresh the `_percolator` index for immediate access.
+#
+Tire.index('_percolator').refresh
+
+# Now, let's _percolate_ a document containing some trigger words against all registered queries.
+#
+matches = index.percolate(:message => '[Warning] Extreme flooding expected after tsunami wave.')
+
+# The result will contain, unsurprisingly, names of all the three registered queries:
+#
+#     Matching queries: ["floods", "tsunami", "warning"]
+#
+puts "Matching queries: " + matches.inspect
+
+# We can filter the executed queries with a regular _ElasticSearch_ query passed as a block to
+# the `percolate` method.
+#
+matches = index.percolate(:message => '[Warning] Extreme flooding expected after tsunami wave.') do
+            # Let's use a _terms_ query against the `tags` field.
+            term :tags, 'tsunami'
+          end
+
+# In this case, the result will contain only the name of the “tsunami” query.
+#
+#     Matching queries: ["tsunami"]
+#
+puts "Matching queries: " + matches.inspect
+
+# What if we percolate another document, without the “tsunami” trigger word?
+#
+matches = index.percolate(:message => '[Warning] Extreme temperatures expected.') { term :tags, 'tsunami' }
+
+# As expected, we will get an empty array:
+#
+#     Matching queries: []
+#
+puts "Matching queries: " + matches.inspect
+
+# Well, that's of course immensely useful for real-time search systems. But, there's more.
+# We can _percolate_ a document _at the same time_ it is being stored in the index,
+# getting back a list of matching queries.
+
+# Let's store a document with some trigger words in the index, and mark it for percolation.
+#
+response = index.store :message => '[Warning] Severe floods expected after tsunami wave.', :percolate => true
+
+# We will get the names of all matching queries in response.
+#
+#     Matching queries: ["floods", "tsunami", "warning"]
+#
+puts "Matching queries: " + response['matches'].inspect
+
+# As with the _percolate_ example, we can filter the executed queries.
+#
+response = index.store :message => '[Warning] Severe floods expected after tsunami wave.',
+                       # Let's use a simple string query for the “tsunami” tag.
+                       :percolate => 'tags:tsunami'
+
+# Unsurprisingly, the response will contain just the name of the “tsunami” query.
+#
+#     Matching queries: ["tsunami"]
+#
+puts "Matching queries: " + response['matches'].inspect
 
 ### ActiveModel Integration
 

data/lib/tire/client.rb

@@ -3,7 +3,7 @@ module Tire
   module Client
 
     class Base
-      def get(url)
+      def get(url, data=nil)
         raise_no_method_error
       end
       def post(url, data)
@@ -21,8 +21,8 @@ module Tire
     end
 
     class RestClient < Base
-      def self.get(url)
-        ::RestClient.get url
+      def self.get(url, data=nil)
+        ::RestClient::Request.new(:method => :get, :url => url, :payload => data).execute
       end
       def self.post(url, data)
         ::RestClient.post url, data

data/lib/tire/index.rb

@@ -42,6 +42,7 @@ module Tire
 
     def store(*args)
       # 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)
@@ -49,6 +50,11 @@ module Tire
         (document = args.pop; type = :document)
       end
 
+      if document.is_a?(Hash)
+        percolate = document.delete(:percolate)
+        percolate = "*" if percolate === true
+      end
+
       old_verbose, $VERBOSE = $VERBOSE, nil # Silence Object#id deprecation warnings
       id = case true
         when document.is_a?(Hash)                                           then document[:id] || document['id']
@@ -62,7 +68,8 @@ module Tire
         else raise ArgumentError, "Please pass a JSON string or object with a 'to_indexed_json' method"
       end
 
-      url = id ? "#{Configuration.url}/#{@name}/#{type}/#{id}" : "#{Configuration.url}/#{@name}/#{type}/"
+      url  = id ? "#{Configuration.url}/#{@name}/#{type}/#{id}" : "#{Configuration.url}/#{@name}/#{type}/"
+      url += "?percolate=#{percolate}" if percolate
 
       @response = Configuration.client.post url, document
       MultiJson.decode(@response.body)
@@ -75,8 +82,6 @@ module Tire
     end
 
     def bulk_store documents
-      create unless exists?
-
       payload = documents.map do |document|
         old_verbose, $VERBOSE = $VERBOSE, nil # Silence Object#id deprecation warnings
         id = case
@@ -209,6 +214,48 @@ module Tire
       logged(error, '_close', curl)
     end
 
+    def register_percolator_query(name, options={}, &block)
+      options[:query] = Search::Query.new(&block).to_hash if block_given?
+
+      @response = Configuration.client.put "#{Configuration.url}/_percolator/#{@name}/#{name}", MultiJson.encode(options)
+      MultiJson.decode(@response.body)['ok']
+      rescue Exception => error
+        raise
+      ensure
+        curl = %Q|curl -X POST "#{Configuration.url}/_percolator/#{@name}/"|
+        logged(error, '_percolator', curl)
+    end
+
+    def percolate(*args, &block)
+      # TODO: Infer type from the document (hash property, method)
+
+      if args.size > 1
+        (type, document = args)
+      else
+        (document = args.pop; type = :document)
+      end
+
+      document = case true
+        when document.is_a?(String) then document
+        when document.respond_to?(:to_hash) then document.to_hash
+        else raise ArgumentError, "Please pass a JSON string or object with a 'to_hash' method"
+      end
+
+      query = Search::Query.new(&block).to_hash if block_given?
+
+      payload = { :doc => document }
+      payload.update( :query => query ) if query
+
+      @response = Configuration.client.get "#{Configuration.url}/#{@name}/#{type}/_percolate", payload.to_json
+      MultiJson.decode(@response.body)['matches']
+
+      rescue Exception => error
+        # raise
+      ensure
+        curl = %Q|curl -X POST "#{Configuration.url}/#{@name}/#{type}/_percolate"|
+        logged(error, '_percolate', curl)
+    end
+
     def logged(error=nil, endpoint='/', curl='')
       if Configuration.logger
 

data/lib/tire/model/callbacks.rb

@@ -15,6 +15,10 @@ module Tire
             def destroyed?; !!@destroyed; end
           end
         end
+
+        base.class_eval do
+          define_model_callbacks(:update_elastic_search_index, :only => [:after, :before])
+        end if base.respond_to?(:define_model_callbacks)
       end
 
     end

data/lib/tire/model/search.rb

@@ -14,7 +14,7 @@ module Tire
           extend  ClassMethods
           include InstanceMethods
 
-          ['_score', '_type', '_index', '_version', 'sort', 'highlight'].each do |attr|
+          ['_score', '_type', '_index', '_version', 'sort', 'highlight', 'matches'].each do |attr|
             # TODO: Find a sane way to add attributes like _score for ActiveRecord -
             #       `define_attribute_methods [attr]` does not work in AR.
             define_method("#{attr}=") { |value| @attributes ||= {}; @attributes[attr] = value }
@@ -68,6 +68,7 @@ module Tire
       module InstanceMethods
 
         def score
+          STDERR.puts "DEPRECATED! Please use #{self.class}#_score instead."
           attributes['_score']
         end
 
@@ -76,12 +77,15 @@ module Tire
         end
 
         def update_elastic_search_index
-          if destroyed?
-            index.remove document_type, self
-          else
-            response  = index.store  document_type, self
-            self.id ||= response['_id'] if self.respond_to?(:id=)
-            self
+          _run_update_elastic_search_index_callbacks do
+            if destroyed?
+              index.remove document_type, self
+            else
+              response  = index.store  document_type, self
+              self.id ||= response['_id'] if self.respond_to?(:id=)
+              self.matches = response['matches']
+              self
+            end
           end
         end
 

data/lib/tire/search.rb

@@ -65,7 +65,7 @@ module Tire
 
       def perform
         @url      = "#{Configuration.url}/#{indices.join(',')}/_search"
-        @response = Configuration.client.post(@url, self.to_json)
+        @response = Configuration.client.get(@url, self.to_json)
         @json     = MultiJson.decode(@response.body)
         @results  = Results::Collection.new(@json, @options)
         self
@@ -77,20 +77,24 @@ module Tire
       end
 
       def to_curl
-        %Q|curl -X POST "#{Configuration.url}/#{indices.join(',')}/_search?pretty=true" -d '#{self.to_json}'|
+        %Q|curl -X GET "#{Configuration.url}/#{indices.join(',')}/_search?pretty=true" -d '#{self.to_json}'|
       end
 
-      def to_json
+      def to_hash
         request = {}
-        request.update( { :query  => @query } )
-        request.update( { :sort   => @sort } )     if @sort
-        request.update( { :facets => @facets } )   if @facets
-        @filters.each { |filter| request.update( { :filter => filter } ) } if @filters
-        request.update( { :highlight => @highlight } ) if @highlight
-        request.update( { :size => @size } )       if @size
-        request.update( { :from => @from } )       if @from
-        request.update( { :fields => @fields } )   if @fields
-        request.to_json
+        request.update( { :query  => @query.to_hash } )    if @query
+        request.update( { :sort   => @sort.to_ary   } )    if @sort
+        request.update( { :facets => @facets.to_hash } )   if @facets
+        @filters.each { |filter| request.update( { :filter => filter.to_hash } ) } if @filters
+        request.update( { :highlight => @highlight.to_hash } ) if @highlight
+        request.update( { :size => @size } )               if @size
+        request.update( { :from => @from } )               if @from
+        request.update( { :fields => @fields } )           if @fields
+        request
+      end
+
+      def to_json
+        to_hash.to_json
       end
 
       def logged(error=nil)

data/lib/tire/version.rb

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

data/test/integration/active_model_searchable_test.rb

@@ -44,7 +44,7 @@ module Tire
         assert_equal 1, results.count
         assert_instance_of SupermodelArticle, results.first
         assert_equal       'Test', results.first.title
-        assert_not_nil     results.first.score
+        assert_not_nil     results.first._score
         assert_equal       id, results.first.id
       end
 

data/test/integration/percolator_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+module Tire
+
+  class PercolatorIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Percolator" do
+      setup do
+        @index = Tire.index('percolator-test')
+        @index.create
+      end
+      teardown { @index.delete }
+
+      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
+
+          percolator = Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+          assert percolator
+        end
+
+        should "register query as block" do
+          assert @index.register_percolator_query('alert') { string 'warning' }
+          sleep 0.1
+
+          percolator = Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+          assert percolator
+        end
+
+      end
+
+      context "when percolating a document" do
+        setup do
+          @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
+        end
+
+        should "return an empty array when no query matches" do
+          matches = @index.percolate :message => 'Situation normal'
+          assert_equal [], matches
+        end
+
+        should "return an array of matching query names" do
+          matches = @index.percolate :message => 'Severe weather warning'
+          assert_equal ['alert','weather'], matches.sort
+        end
+
+        should "return an array of matching query names for specific percolated queries" do
+          matches = @index.percolate(:message => 'Severe weather warning') { term :tags, 'weather' }
+          assert_equal ['weather'], matches
+        end
+      end
+
+      context "when storing document and percolating it" do
+        setup do
+          @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
+        end
+
+        should "return an empty array when no query matches" do
+          response = @index.store :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
+          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'
+          assert_equal ['weather'], response['matches']
+        end
+      end
+
+    end
+
+  end
+end

data/test/unit/index_test.rb

@@ -393,6 +393,123 @@ module Tire
 
       end
 
+      context "when percolating" do
+
+        should "register percolator query as a Hash" do
+          query = { :query => { :query_string => { :query => 'foo' } } }
+          Configuration.client.expects(:post).with do |url, payload|
+                                               payload = MultiJson.decode(payload)
+                                               url == "#{Configuration.url}/_percolator/dummy/my-query" &&
+                                               payload['query']['query_string']['query'] == 'foo'
+                               end.
+                               returns(mock_response('{
+                                                        "ok" : true,
+                                                        "_index" : "_percolator",
+                                                        "_type" : "dummy",
+                                                        "_id" : "my-query",
+                                                        "_version" : 1
+                                                     }'))
+
+          @index.register_percolator_query 'my-query', query
+        end
+
+        should "register percolator query as a block" do
+          Configuration.client.expects(:post).with do |url, payload|
+                                               payload = MultiJson.decode(payload)
+                                               url == "#{Configuration.url}/_percolator/dummy/my-query" &&
+                                               payload['query']['query_string']['query'] == 'foo'
+                               end.
+                               returns(mock_response('{
+                                                        "ok" : true,
+                                                        "_index" : "_percolator",
+                                                        "_type" : "dummy",
+                                                        "_id" : "my-query",
+                                                        "_version" : 1
+                                                     }'))
+
+          @index.register_percolator_query 'my-query' do
+            string 'foo'
+          end
+        end
+
+        should "register percolator query with a key" do
+          query = { :query => { :query_string => { :query => 'foo' } },
+                    :tags  => ['alert'] }
+
+          Configuration.client.expects(:post).with do |url, payload|
+                                               payload = MultiJson.decode(payload)
+                                               url == "#{Configuration.url}/_percolator/dummy/my-query" &&
+                                               payload['query']['query_string']['query'] == 'foo'
+                                               payload['tags'] == ['alert']
+                                           end.
+                               returns(mock_response('{
+                                                        "ok" : true,
+                                                        "_index" : "_percolator",
+                                                        "_type" : "dummy",
+                                                        "_id" : "my-query",
+                                                        "_version" : 1
+                                                     }'))
+
+          assert @index.register_percolator_query('my-query', query)
+        end
+
+        should "percolate document against all registered queries" do
+          Configuration.client.expects(:post).with do |url,payload|
+                                               payload = MultiJson.decode(payload)
+                                               url == "#{Configuration.url}/dummy/document/_percolate" &&
+                                               payload['doc']['title'] == 'Test'
+                                              end.
+                               returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
+
+          matches = @index.percolate :title => 'Test'
+          assert_equal ["alerts"], matches
+        end
+
+        should "percolate a typed document against all registered queries" do
+          Configuration.client.expects(:post).with do |url,payload|
+                                               payload = MultiJson.decode(payload)
+                                               url == "#{Configuration.url}/dummy/article/_percolate" &&
+                                               payload['doc']['title'] == 'Test'
+                                              end.
+                               returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
+
+          matches = @index.percolate :article, :title => 'Test'
+          assert_equal ["alerts"], matches
+        end
+
+        should "percolate document against specific queries" do
+          Configuration.client.expects(:post).with do |url,payload|
+                                               payload = MultiJson.decode(payload)
+                                               # p [url, payload]
+                                               url == "#{Configuration.url}/dummy/document/_percolate" &&
+                                               payload['doc']['title']                   == 'Test' &&
+                                               payload['query']['query_string']['query'] == 'tag:alerts'
+                                              end.
+                               returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
+
+          matches = @index.percolate(:title => 'Test') { string 'tag:alerts' }
+          assert_equal ["alerts"], matches
+        end
+
+        context "when 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
+          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'
+            assert_equal response['matches'], ['alerts']
+          end
+
+        end
+
+      end
+
     end
 
   end

data/test/unit/model_persistence_test.rb

@@ -86,21 +86,21 @@ module Tire
         end
 
         should "find document by list of IDs" do
-          Configuration.client.expects(:post).returns(mock_response(@find_last_two.to_json))
+          Configuration.client.expects(:get).returns(mock_response(@find_last_two.to_json))
           documents = PersistentArticle.find 2, 3
 
           assert_equal 2, documents.count
         end
 
         should "find document by array of IDs" do
-          Configuration.client.expects(:post).returns(mock_response(@find_last_two.to_json))
+          Configuration.client.expects(:get).returns(mock_response(@find_last_two.to_json))
           documents = PersistentArticle.find [2, 3]
 
           assert_equal 2, documents.count
         end
 
         should "find all documents" do
-          Configuration.client.stubs(:post).returns(mock_response(@find_all.to_json))
+          Configuration.client.stubs(:get).returns(mock_response(@find_all.to_json))
           documents = PersistentArticle.all
 
           assert_equal 3, documents.count
@@ -109,7 +109,7 @@ module Tire
         end
 
         should "find first document" do
-          Configuration.client.expects(:post).returns(mock_response(@find_first.to_json))
+          Configuration.client.expects(:get).returns(mock_response(@find_first.to_json))
           document = PersistentArticle.first
 
           assert_equal 'First', document.attributes['title']

data/test/unit/model_search_test.rb

@@ -1,5 +1,16 @@
 require 'test_helper'
 
+class ModelWithIndexCallbacks
+  extend ActiveModel::Naming
+  extend ActiveModel::Callbacks
+
+  include Tire::Model::Search
+  include Tire::Model::Callbacks
+
+  def destroyed?;         false;        end
+  def serializable_hash;  {:one => 1};  end
+end
+
 module Tire
   module Model
 
@@ -20,6 +31,11 @@ module Tire
           assert_respond_to ActiveModelArticle, :search
         end
 
+        should "have the `update_elastic_search_index` callback methods defined" do
+          assert_respond_to ::ModelWithIndexCallbacks, :before_update_elastic_search_index
+          assert_respond_to ::ModelWithIndexCallbacks, :after_update_elastic_search_index
+        end
+
         should_eventually "contain all Tire class/instance methods in a proxy object" do
         end
 
@@ -70,7 +86,7 @@ module Tire
 
         should "wrap results in proper class with ID and score and not change the original wrapper" do
           response = { 'hits' => { 'hits' => [{'_id' => 1, '_score' => 0.8, '_source' => { 'title' => 'Article' }}] } }
-          Configuration.client.expects(:post).returns(mock_response(response.to_json))
+          Configuration.client.expects(:get).returns(mock_response(response.to_json))
 
           collection = ActiveModelArticle.search 'foo'
           assert_instance_of Results::Collection, collection
@@ -200,7 +216,7 @@ module Tire
 
         should "store the record in index on :update_elastic_search_index when saved" do
           @model = ActiveModelArticleWithCallbacks.new
-          Tire::Index.any_instance.expects(:store)
+          Tire::Index.any_instance.expects(:store).returns({})
 
           @model.save
         end
@@ -226,6 +242,7 @@ module Tire
 
             class ::ModelWithCustomMapping
               extend ActiveModel::Naming
+              extend ActiveModel::Callbacks
 
               include Tire::Model::Search
               include Tire::Model::Callbacks
@@ -241,6 +258,52 @@ module Tire
 
         end
 
+        context "with index update callbacks" do
+          setup do
+            class ::ModelWithIndexCallbacks
+              _update_elastic_search_index_callbacks.clear
+              def notify; end
+            end
+
+            response = { 'ok'  => true,
+                         '_id' => 1,
+                         'matches' => ['foo'] }
+            Configuration.client.expects(:post).returns(mock_response(response.to_json))
+          end
+
+          should "run the callback defined as block" do
+            class ::ModelWithIndexCallbacks
+              after_update_elastic_search_index { self.go! }
+            end
+
+            @model = ::ModelWithIndexCallbacks.new
+            @model.expects(:go!)
+
+            @model.update_elastic_search_index
+          end
+
+          should "run the callback defined as symbol" do
+            class ::ModelWithIndexCallbacks
+              after_update_elastic_search_index :notify
+
+              def notify; self.go!; end
+            end
+
+            @model = ::ModelWithIndexCallbacks.new
+            @model.expects(:go!)
+
+            @model.update_elastic_search_index
+          end
+
+          should "set the 'matches' property from percolated response" do
+            @model = ::ModelWithIndexCallbacks.new
+            @model.update_elastic_search_index
+
+            assert_equal ['foo'], @model.matches
+          end
+
+        end
+
         context "serialization" do
           setup { Tire::Index.any_instance.stubs(:create).returns(true) }
 
@@ -253,6 +316,7 @@ module Tire
 
             class ::ModelWithoutMapping
               extend  ActiveModel::Naming
+              extend ActiveModel::Callbacks
               include ActiveModel::Serialization
               include Tire::Model::Search
               include Tire::Model::Callbacks
@@ -279,6 +343,7 @@ module Tire
 
             class ::ModelWithMapping
               extend  ActiveModel::Naming
+              extend ActiveModel::Callbacks
               include ActiveModel::Serialization
               include Tire::Model::Search
               include Tire::Model::Callbacks

data/test/unit/search_test.rb

@@ -43,7 +43,7 @@ module Tire
         s = Search::Search.new('index') do
           query { string 'title:foo' }
         end
-        assert_equal %q|curl -X POST "http://localhost:9200/index/_search?pretty=true" -d | +
+        assert_equal %q|curl -X GET "http://localhost:9200/index/_search?pretty=true" -d | +
                      %q|'{"query":{"query_string":{"query":"title:foo"}}}'|,
                      s.to_curl
       end
@@ -55,6 +55,16 @@ module Tire
         assert_match /index_1,index_2/, s.to_curl
       end
 
+      should "return itself as a Hash" do
+        s = Search::Search.new('index_1', 'index_2') do
+          query { string 'title:foo' }
+        end
+        assert_nothing_raised do
+          assert_instance_of Hash,  s.to_hash
+          assert_equal "title:foo", s.to_hash[:query][:query_string][:query]
+        end
+      end
+
       should "allow chaining" do
         assert_nothing_raised do
           Search::Search.new('index').query { }.sort { title 'desc' }.size(5).sort { name 'asc' }.from(1)
@@ -63,7 +73,7 @@ module Tire
 
       should "perform the search" do
         response = stub(:body => '{"took":1,"hits":[]}', :code => 200)
-        Configuration.client.expects(:post).returns(response)
+        Configuration.client.expects(:get).returns(response)
         Results::Collection.expects(:new).returns([])
 
         s = Search::Search.new('index')
@@ -73,7 +83,7 @@ module Tire
       end
 
       should "print debugging information on exception and re-raise it" do
-        Configuration.client.expects(:post).raises(RestClient::InternalServerError)
+        Configuration.client.expects(:get).raises(RestClient::InternalServerError)
         STDERR.expects(:puts)
 
         s = Search::Search.new('index')
@@ -84,7 +94,7 @@ module Tire
         Configuration.logger STDERR
 
         response = stub(:body => '{"took":1,"hits":[]}', :code => 200)
-        Configuration.client.expects(:post).returns(response)
+        Configuration.client.expects(:get).returns(response)
 
         Results::Collection.expects(:new).returns([])
         Configuration.logger.expects(:log_request).returns(true)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tire
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: 
   segments: 
   - 0
   - 1
-  - 8
-  version: 0.1.8
+  - 9
+  version: 0.1.9
 platform: ruby
 authors: 
 - Karel Minarik
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-08 00:00:00 +02:00
+date: 2011-06-13 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -300,6 +300,7 @@ files:
 - test/integration/highlight_test.rb
 - test/integration/index_mapping_test.rb
 - test/integration/index_store_test.rb
+- test/integration/percolator_test.rb
 - test/integration/persistent_model_test.rb
 - test/integration/query_string_test.rb
 - test/integration/results_test.rb
@@ -384,6 +385,7 @@ test_files:
 - test/integration/highlight_test.rb
 - test/integration/index_mapping_test.rb
 - test/integration/index_store_test.rb
+- test/integration/percolator_test.rb
 - test/integration/persistent_model_test.rb
 - test/integration/query_string_test.rb
 - test/integration/results_test.rb