[STORE] Added the find_each method for models

    Person.find_each { |person| puts person.name }

    # # GET http://localhost:9200/people/person/_search?scroll=5m&search_type=scan&size=20
    # # GET http://localhost:9200/_search/scroll?scroll=5m&scroll_id=c2Nhbj...
    # Test 0
    # Test 1
    # Test 2
    # ...
    # # GET http://localhost:9200/_search/scroll?scroll=5m&scroll_id=c2Nhbj...
    # Test 20
    # Test 21
    # Test 22

See: http://api.rubyonrails.org/classes/ActiveRecord/Batches.html#method-i-find_each

Author: karmi

elasticsearch-persistence/lib/elasticsearch/persistence/model/find.rb

@@ -25,8 +25,12 @@ def all(options={})
           #
           # You can restrict the models being returned with a query.
           #
-          # The full {Persistence::Repository::Response::Result} instance is yielded to the passed
-          # block in each batch, so you can access any of its properties. Calling `to_a` will
+          # The {http://rubydoc.info/gems/elasticsearch-api/Elasticsearch/API/Actions#search-instance_method Search API}
+          # options are passed to the search method as parameters, all remaining options are passed
+          # as the `:body` parameter.
+          #
+          # The full {Persistence::Repository::Response::Results} instance is yielded to the passed
+          # block in each batch, so you can access any of its properties; calling `to_a` will
           # convert the object to an Array of model instances.
           #
           # @example Return all models in batches of 20 x number of primary shards
@@ -102,6 +106,40 @@ def find_in_batches(options={}, &block)
 
             return response['_scroll_id']
           end
+
+          # Iterate effectively over models using the `find_in_batches` method.
+          #
+          # All the options are passed to `find_in_batches` and each result is yielded to the passed block.
+          #
+          # @example Print out the people's names by scrolling through the index
+          #
+          #     Person.find_each { |person| puts person.name }
+          #
+          #     # # GET http://localhost:9200/people/person/_search?scroll=5m&search_type=scan&size=20
+          #     # # GET http://localhost:9200/_search/scroll?scroll=5m&scroll_id=c2Nhbj...
+          #     # Test 0
+          #     # Test 1
+          #     # Test 2
+          #     # ...
+          #     # # GET http://localhost:9200/_search/scroll?scroll=5m&scroll_id=c2Nhbj...
+          #     # Test 20
+          #     # Test 21
+          #     # Test 22
+          #
+          # @example Leave out the block to return an Enumerator instance
+          #
+          #     Person.find_each.select { |person| person.name =~ /John/ }
+          #     # => => [#<Person {id: "NkltJP5vRxqk9_RMP7SU8Q", name: "John Smith",  ...}>]
+          #
+          # @return [String,Enumerator] The `scroll_id` for the request or Enumerator when the block is not passed
+          #
+          def find_each(options = {})
+            return to_enum(:find_each, options) unless block_given?
+
+            find_in_batches(options) do |batch|
+              batch.each { |result| yield result }
+            end
+          end
         end
       end
 

elasticsearch-persistence/test/integration/model/model_basic_test.rb

@@ -100,16 +100,33 @@ class ::Person
         end
 
         should "find instances in batches" do
-          100.times { |i| Person.create name: "John #{i+1}" }
+          50.times { |i| Person.create name: "John #{i+1}" }
           Person.gateway.refresh_index!
 
+          @batches = 0
           @results = []
 
           Person.find_in_batches(_source_include: 'name') do |batch|
+            @batches += 1
             @results += batch.map(&:name)
           end
 
-          assert_equal 100, @results.size
+          assert_equal  3, @batches
+          assert_equal 50, @results.size
+          assert_contains @results, 'John 1'
+        end
+
+        should "find each instance" do
+          50.times { |i| Person.create name: "John #{i+1}" }
+          Person.gateway.refresh_index!
+
+          @results = []
+
+          Person.find_each(_source_include: 'name') do |person|
+            @results << person.name
+          end
+
+          assert_equal 50, @results.size
           assert_contains @results, 'John 1'
         end
       end

elasticsearch-persistence/test/unit/model_find_test.rb

@@ -83,39 +83,66 @@ def set_id(id); self.id = id; end
       DummyFindModel.all( { query: { match: { title: 'test' } }, routing: 'abc123' } )
     end
 
-    should "find all records in batches" do
-      @gateway
+    context "finding via scan/scroll" do
+      setup do
+        @gateway
         .expects(:deserialize)
         .with('_source' => {'foo' => 'bar'})
         .returns('_source' => {'foo' => 'bar'})
 
-      @gateway.client
-        .expects(:search)
-        .with do |arguments|
-          assert_equal 'scan', arguments[:search_type]
-          assert_equal 'foo',  arguments[:index]
-          assert_equal 'bar',  arguments[:type]
-        end
-        .returns(MultiJson.load('{"_scroll_id":"abc123==", "hits":{"hits":[]}}'))
+        @gateway.client
+          .expects(:search)
+          .with do |arguments|
+            assert_equal 'scan', arguments[:search_type]
+            assert_equal 'foo',  arguments[:index]
+            assert_equal 'bar',  arguments[:type]
+          end
+          .returns(MultiJson.load('{"_scroll_id":"abc123==", "hits":{"hits":[]}}'))
+
+        @gateway.client
+          .expects(:scroll)
+          .twice
+          .returns(MultiJson.load('{"_scroll_id":"abc456==", "hits":{"hits":[{"_source":{"foo":"bar"}}]}}'))
+          .then
+          .returns(MultiJson.load('{"_scroll_id":"abc789==", "hits":{"hits":[]}}'))
+      end
 
-      @gateway.client
-        .expects(:scroll)
-        .twice
-        .returns(MultiJson.load('{"_scroll_id":"abc456==", "hits":{"hits":[{"_source":{"foo":"bar"}}]}}'))
-        .then
-        .returns(MultiJson.load('{"_scroll_id":"abc789==", "hits":{"hits":[]}}'))
+      should "find all records in batches" do
+        @doc = nil
+        result = DummyFindModel.find_in_batches { |batch| @doc = batch.first['_source']['foo'] }
 
-      @doc = nil
+        assert_equal 'abc789==', result
+        assert_equal 'bar',      @doc
+      end
 
-      result = DummyFindModel.find_in_batches { |batch| @doc = batch.first['_source']['foo'] }
+      should "return an Enumerator for find in batches" do
+        @doc = nil
+        assert_nothing_raised do
+          e = DummyFindModel.find_in_batches
+          assert_instance_of Enumerator, e
 
-      assert_equal 'abc789==', result
-      assert_equal 'bar',      @doc
-    end
+          e.each { |batch| @doc = batch.first['_source']['foo'] }
+          assert_equal 'bar',      @doc
+        end
+      end
+
+      should "find each" do
+        @doc = nil
+        result = DummyFindModel.find_each { |doc| @doc = doc['_source']['foo'] }
+
+        assert_equal 'abc789==', result
+        assert_equal 'bar',      @doc
+      end
+
+      should "return an Enumerator for find each" do
+        @doc = nil
+        assert_nothing_raised do
+          e = DummyFindModel.find_each
+          assert_instance_of Enumerator, e
 
-    should "return an Enumerator for find in batches" do
-      assert_nothing_raised do
-        assert_instance_of Enumerator, DummyFindModel.find_in_batches
+          e.each { |doc| @doc = doc['_source']['foo'] }
+          assert_equal 'bar',      @doc
+        end
       end
     end