[MODEL] Added support for will_paginate pagination library

This patch adds support for the [`will_paginate`](https://github.com/mislav/will_paginate) gem,
functionally equivalent to the Kaminari integration.

Closes elastic#49

Author: balexand

README.md

@@ -8,8 +8,8 @@ This repository contains ActiveModel, ActiveRecord and Ruby on Rails integration
 * ActiveRecord::Relation-based wrapper for returning search results as records
 * Convenience model methods such as `search`, `mapping`, `import`, etc
 * Rake tasks for importing the data
-* Kaminari-based pagination support
-* Integration with Rails's instrumentation framework
+* Support for Kaminari and WillPaginate pagination
+* Integration with Rails' instrumentation framework
 * Templates for generating example Rails application
 
 Elasticsearch client and Ruby API is provided by the

elasticsearch-model/README.md

@@ -252,9 +252,10 @@ response.records.each_with_hit { |record, hit| puts "* #{record.title}: #{hit._s
 #### Pagination
 
 You can implement pagination with the `from` and `size` search parameters. However, search results
-can be automatically paginated with the [`kaminari`](http://rubygems.org/gems/kaminari) gem.
+can be automatically paginated with the [`kaminari`](http://rubygems.org/gems/kaminari) or
+[`will_paginate`](https://github.com/mislav/will_paginate) gems.
 
-If Kaminari is loaded, use the familiar paging methods:
+If Kaminari or WillPaginate is loaded, use the familiar paging methods:
 
 ```ruby
 response.page(2).results
@@ -271,7 +272,7 @@ In a Rails controller, use the the `params[:page]` parameter to paginate through
 @articles.next_page
 # => 3
 ```
-To initialize and include the pagination support manually:
+To initialize and include the Kaminari pagination support manually:
 
 ```ruby
 Kaminari::Hooks.init

elasticsearch-model/elasticsearch-model.gemspec

@@ -36,6 +36,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "oj"
   s.add_development_dependency "kaminari"
+  s.add_development_dependency "will_paginate"
   # NOTE: Do not add Mongoid here, keep only in 3/4 files
 
   s.add_development_dependency "minitest", "~> 4.0"

elasticsearch-model/lib/elasticsearch/model.rb

@@ -31,8 +31,11 @@
 
 require 'elasticsearch/model/ext/active_record'
 
-if defined?(::Kaminari)
+case
+when defined?(::Kaminari)
   Elasticsearch::Model::Response::Response.__send__ :include, Elasticsearch::Model::Response::Pagination::Kaminari
+when defined?(::WillPaginate)
+  Elasticsearch::Model::Response::Response.__send__ :include, Elasticsearch::Model::Response::Pagination::WillPaginate
 end
 
 module Elasticsearch

elasticsearch-model/lib/elasticsearch/model/response/pagination.rb

@@ -93,6 +93,71 @@ def total_count
             results.total
           end
         end
+
+        # Allow models to be paginated with the "will_paginate" gem [https://github.com/mislav/will_paginate]
+        #
+        module WillPaginate
+          def self.included(base)
+            base.__send__ :include, ::WillPaginate::CollectionMethods
+
+            # Include the paging methods in results and records
+            #
+            methods = [:current_page, :per_page, :total_entries, :total_pages, :previous_page, :next_page, :out_of_bounds?]
+            Elasticsearch::Model::Response::Results.__send__ :delegate, *methods, to: :response
+            Elasticsearch::Model::Response::Records.__send__ :delegate, *methods, to: :response
+          end
+
+          # Main pagination method
+          #
+          # @example
+          #
+          #     Article.search('foo').paginate(page: 1, per_page: 30)
+          #
+          def paginate(options)
+            page = [options[:page].to_i, 1].max
+            per_page = (options[:per_page] || klass.per_page).to_i
+
+            search.definition.update size: per_page,
+                                     from: (page - 1) * per_page
+            self
+          end
+
+          # Return the current page
+          #
+          def current_page
+            search.definition[:from] / per_page + 1 if search.definition[:from] && per_page
+          end
+
+          # Pagination method
+          #
+          # @example
+          #
+          #     Article.search('foo').page(2)
+          #
+          def page(num)
+            paginate(page: num, per_page: per_page) # shorthand
+          end
+
+          # Return or set the "size" value
+          #
+          # @example
+          #
+          #     Article.search('foo').per_page(15).page(2)
+          #
+          def per_page(num = nil)
+            if num.nil?
+              search.definition[:size]
+            else
+              paginate(page: current_page, per_page: num) # shorthand
+            end
+          end
+
+          # Returns the total number of results
+          #
+          def total_entries
+            results.total
+          end
+        end
       end
 
     end

elasticsearch-model/test/unit/response_pagination_test.rb elasticsearch-model/test/unit/response_pagination_kaminari_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class Elasticsearch::Model::ResponsePaginationTest < Test::Unit::TestCase
+class Elasticsearch::Model::ResponsePaginationKaminariTest < Test::Unit::TestCase
   context "Response pagination" do
     class ModelClass
       include ::Kaminari::ConfigurationMethods

elasticsearch-model/test/unit/response_pagination_will_paginate_test.rb

@@ -0,0 +1,189 @@
+require 'test_helper'
+require 'will_paginate'
+require 'will_paginate/collection'
+
+class Elasticsearch::Model::ResponsePaginationWillPaginateTest < Test::Unit::TestCase
+  context "Response pagination" do
+    class ModelClass
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+
+      # WillPaginate adds this method to models (see WillPaginate::PerPage module)
+      def self.per_page
+        33
+      end
+    end
+
+    # Subsclass Response so we can include WillPaginate module without conflicts with Kaminari.
+    class WillPaginateResponse < Elasticsearch::Model::Response::Response
+      include Elasticsearch::Model::Response::Pagination::WillPaginate
+    end
+
+    RESPONSE = { 'took' => '5', 'timed_out' => false, '_shards' => {'one' => 'OK'},
+                 'hits' => { 'total' => 100, 'hits' => (1..100).to_a.map { |i| { _id: i } } } }
+
+    setup do
+      @search   = Elasticsearch::Model::Searching::SearchRequest.new ModelClass, '*'
+      @response = WillPaginateResponse.new ModelClass, @search, RESPONSE
+      @response.klass.stubs(:client).returns mock('client')
+
+      @expected_methods = [
+        # methods needed by WillPaginate::CollectionMethods
+        :current_page,
+        :per_page,
+        :total_entries,
+
+        # methods defined by WillPaginate::CollectionMethods
+        :total_pages,
+        :previous_page,
+        :next_page,
+        :out_of_bounds?,
+      ]
+    end
+
+    should "have pagination methods" do
+      assert_respond_to @response, :paginate
+
+      @expected_methods.each do |method|
+        assert_respond_to @response, method
+      end
+    end
+
+    context "response.results" do
+      should "have pagination methods" do
+        @expected_methods.each do |method|
+          assert_respond_to @response.results, method
+        end
+      end
+    end
+
+    context "response.records" do
+      should "have pagination methods" do
+        @expected_methods.each do |method|
+          @response.klass.stubs(:find).returns([])
+          assert_respond_to @response.records, method
+        end
+      end
+    end
+
+    context "#paginate method" do
+      should "set from/size using defaults" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 0, definition[:from]
+              assert_equal 33, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: nil).to_a
+        assert_equal 0, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+
+      should "set from/size using default per_page" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 33, definition[:from]
+              assert_equal 33, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: 2).to_a
+        assert_equal 33, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+
+      should "set from/size using custom page and per_page" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 18, definition[:from]
+              assert_equal 9, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: 3, per_page: 9).to_a
+        assert_equal 18, @response.search.definition[:from]
+        assert_equal 9, @response.search.definition[:size]
+      end
+
+      should "searches for page 1 if specified page is < 1" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 0, definition[:from]
+              assert_equal 33, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: "-1").to_a
+        assert_equal 0, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+    end
+
+    context "#page and #per_page shorthand methods" do
+      should "set from/size using default per_page" do
+        @response.page(5)
+        assert_equal 132, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+
+      should "set from/size when calling #page then #per_page" do
+        @response.page(5).per_page(3)
+        assert_equal 12, @response.search.definition[:from]
+        assert_equal 3, @response.search.definition[:size]
+      end
+
+      should "set from/size when calling #per_page then #page" do
+        @response.per_page(3).page(5)
+        assert_equal 12, @response.search.definition[:from]
+        assert_equal 3, @response.search.definition[:size]
+      end
+    end
+
+    context "#current_page method" do
+      should "return 1 by default" do
+        @response.paginate({})
+        assert_equal 1, @response.current_page
+      end
+
+      should "return current page number" do
+        @response.paginate(page: 3, per_page: 9)
+        assert_equal 3, @response.current_page
+      end
+
+      should "return nil if not pagination set" do
+        assert_equal nil, @response.current_page
+      end
+    end
+
+    context "#per_page method" do
+      should "return value set in paginate call" do
+        @response.paginate(per_page: 8)
+        assert_equal 8, @response.per_page
+      end
+    end
+
+    context "#total_entries method" do
+      should "return total from response" do
+        @response.expects(:results).returns(mock('results', total: 100))
+        assert_equal 100, @response.total_entries
+      end
+    end
+  end
+end