[STORE] Added the Search module

The module provides an interface for getting objects from the repository
based on a search query.

The results are wrapped in the `Response::Results` instance, which
proxies methods to the `results` property.

Author: karmi

elasticsearch-persistence/elasticsearch-persistence.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency "elasticsearch",       '> 0.4'
   s.add_dependency "active_support"
+  s.add_dependency "hashie"
 
   s.add_development_dependency "bundler", "~> 1.5"
   s.add_development_dependency "rake"

elasticsearch-persistence/lib/elasticsearch/persistence.rb

@@ -1,14 +1,17 @@
 require 'elasticsearch'
+require 'hashie'
 
 require 'active_support/inflector'
 
 require 'elasticsearch/persistence/version'
 
 require 'elasticsearch/persistence/client'
+require 'elasticsearch/persistence/repository/response/results'
 require 'elasticsearch/persistence/repository/naming'
 require 'elasticsearch/persistence/repository/serialize'
 require 'elasticsearch/persistence/repository/store'
 require 'elasticsearch/persistence/repository/find'
+require 'elasticsearch/persistence/repository/search'
 require 'elasticsearch/persistence/repository'
 
 require 'elasticsearch/persistence/repository/class'

elasticsearch-persistence/lib/elasticsearch/persistence/repository.rb

@@ -7,6 +7,7 @@ module Repository
       include Elasticsearch::Persistence::Repository::Serialize
       include Elasticsearch::Persistence::Repository::Store
       include Elasticsearch::Persistence::Repository::Find
+      include Elasticsearch::Persistence::Repository::Search
 
       def new(options={}, &block)
         Elasticsearch::Persistence::Repository::Class.new options, &block

elasticsearch-persistence/lib/elasticsearch/persistence/repository/response/results.rb

@@ -0,0 +1,54 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+      module Response
+
+        class Results
+          include Enumerable
+
+          attr_reader :repository, :response, :response
+
+          def initialize(repository, response, options={})
+            @repository = repository
+            @response   = Hashie::Mash.new(response)
+            @options    = options
+          end
+
+          def method_missing(method_name, *arguments, &block)
+            results.respond_to?(method_name) ? results.__send__(method_name, *arguments, &block) : super
+          end
+
+          def respond_to?(method_name, include_private = false)
+            results.respond_to?(method_name) || super
+          end
+
+          def total
+            response['hits']['total']
+          end
+
+          def max_score
+            response['hits']['max_score']
+          end
+
+          # Yields [object, hit] pairs to the block
+          #
+          def each_with_hit(&block)
+            results.zip(response['hits']['hits']).each(&block)
+          end
+
+          # Yields [object, hit] pairs and returns the result
+          #
+          def map_with_hit(&block)
+            results.zip(response['hits']['hits']).map(&block)
+          end
+
+          def results
+            @results ||= response['hits']['hits'].map do |document|
+              repository.deserialize(document.to_hash)
+            end
+          end
+        end
+      end
+    end
+  end
+end

elasticsearch-persistence/lib/elasticsearch/persistence/repository/search.rb

@@ -0,0 +1,23 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+
+      module Search
+        def search(query_or_definition, options={})
+          type     = (klass ? __get_type_from_class(klass) : nil  )
+          case
+          when query_or_definition.respond_to?(:to_hash)
+            response = client.search( { index: 'test', type: type, body: query_or_definition.to_hash }.merge(options) )
+          when query_or_definition.is_a?(String)
+            response = client.search( { index: 'test', type: type, q: query_or_definition }.merge(options) )
+          else
+            raise ArgumentError, "[!] Pass the search definition as a Hash-like object or pass the query as a String" +
+                                 " -- #{query_or_definition.class} given."
+          end
+          Response::Results.new(self, response)
+        end
+      end
+
+    end
+  end
+end

elasticsearch-persistence/test/unit/repository_response_results_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+class Elasticsearch::Persistence::RepositoryResponseResultsTest < Test::Unit::TestCase
+  include Elasticsearch::Persistence
+  class MyDocument; end
+
+  context "Response results" do
+    setup do
+      @repository = Repository.new
+
+      @response = { "took" => 2,
+                   "timed_out" => false,
+                   "_shards" => {"total" => 5, "successful" => 5, "failed" => 0},
+                   "hits" =>
+                    { "total" => 2,
+                      "max_score" => 0.19,
+                      "hits" =>
+                       [{"_index" => "test",
+                         "_type" => "note",
+                         "_id" => "1",
+                         "_score" => 0.19,
+                         "_source" => {"id" => 1, "title" => "Test 1"}},
+
+                         {"_index" => "test",
+                         "_type" => "note",
+                         "_id" => "2",
+                         "_score" => 0.19,
+                         "_source" => {"id" => 2, "title" => "Test 2"}}
+                       ]
+                    }
+                  }
+
+      @shoulda_subject = Repository::Response::Results.new @repository, @response
+    end
+
+    should "provide the access to the repository" do
+      assert_instance_of Repository::Class, subject.repository
+    end
+
+    should "provide the access to the response" do
+      assert_equal 5, subject.response['_shards']['total']
+    end
+
+    should "wrap the response in Hashie::Mash" do
+      assert_equal 5, subject.response._shards.total
+    end
+
+    should "return the total" do
+      assert_equal 2, subject.total
+    end
+
+    should "return the max_score" do
+      assert_equal 0.19, subject.max_score
+    end
+
+    should "delegate methods to results" do
+      subject.repository
+        .expects(:deserialize)
+        .twice
+        .returns(MyDocument.new)
+
+      assert_equal 2, subject.size
+      assert_respond_to subject, :each
+    end
+
+    should "yield each object with hit" do
+      @shoulda_subject = Repository::Response::Results.new \
+        @repository,
+        { 'hits' => { 'hits' => [{'_id' => '1', 'foo' => 'bar'}] } }
+
+      subject.repository
+        .expects(:deserialize)
+        .returns('FOO')
+
+      subject.each_with_hit do |object, hit|
+        assert_equal 'FOO', object
+        assert_equal 'bar', hit.foo
+      end
+    end
+
+    should "map objects and hits" do
+      @shoulda_subject = Repository::Response::Results.new \
+        @repository,
+        { 'hits' => { 'hits' => [{'_id' => '1', 'foo' => 'bar'}] } }
+
+      subject.repository
+        .expects(:deserialize)
+        .returns('FOO')
+
+      assert_equal ['FOO---bar'], subject.map_with_hit { |object, hit| "#{object}---#{hit.foo}" }
+    end
+  end
+
+end

elasticsearch-persistence/test/unit/repository_search_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+class Elasticsearch::Persistence::RepositorySearchTest < Test::Unit::TestCase
+  class MyDocument; end
+
+  context "The repository search" do
+    setup do
+      @shoulda_subject = Class.new() { include Elasticsearch::Persistence::Repository::Search }.new
+
+      @client = mock
+      @shoulda_subject.stubs(:klass).returns(nil)
+      @shoulda_subject.stubs(:client).returns(@client)
+    end
+
+    should "search in type based on klass" do
+      subject.expects(:klass).returns(MyDocument).at_least_once
+      subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+
+      @client.expects(:search).with do |arguments|
+        assert_equal 'test',        arguments[:index]
+        assert_equal 'my_document', arguments[:type]
+
+        assert_equal({foo: 'bar'}, arguments[:body])
+      end
+
+      subject.search foo: 'bar'
+    end
+
+    should "search across all types" do
+      subject.expects(:klass).returns(nil).at_least_once
+      subject.expects(:__get_type_from_class).never
+
+      @client.expects(:search).with do |arguments|
+        assert_equal 'test', arguments[:index]
+        assert_equal nil,    arguments[:type]
+
+        assert_equal({foo: 'bar'}, arguments[:body])
+      end
+
+      assert_instance_of Elasticsearch::Persistence::Repository::Response::Results,
+                         subject.search(foo: 'bar')
+    end
+
+    should "pass options to the client" do
+      subject.expects(:klass).returns(nil).at_least_once
+      subject.expects(:__get_type_from_class).never
+
+      @client.expects(:search).twice.with do |arguments|
+        assert_equal 'bambam', arguments[:routing]
+      end
+
+      assert_instance_of Elasticsearch::Persistence::Repository::Response::Results,
+                         subject.search( {foo: 'bar'}, { routing: 'bambam' } )
+      assert_instance_of Elasticsearch::Persistence::Repository::Response::Results,
+                         subject.search( 'foobar', { routing: 'bambam' } )
+    end
+
+    should "search with simple search" do
+      subject.expects(:klass).returns(nil).at_least_once
+      subject.expects(:__get_type_from_class).never
+
+      @client.expects(:search).with do |arguments|
+        assert_equal 'foobar', arguments[:q]
+      end
+
+      assert_instance_of Elasticsearch::Persistence::Repository::Response::Results,
+                         subject.search('foobar')
+    end
+
+    should "raise error for incorrect search definitions" do
+      subject.expects(:klass).returns(nil).at_least_once
+      subject.expects(:__get_type_from_class).never
+
+      assert_raise ArgumentError do
+        subject.search 123
+      end
+    end
+  end
+
+end