Add support for Pagy (closes #97)

Author: davidcelis

.travis.yml

@@ -7,5 +7,6 @@ rvm:
   - 2.5.0
 script: bundle exec rspec
 env:
+  - PAGINATOR=pagy
   - PAGINATOR=kaminari
   - PAGINATOR=will_paginate

Gemfile

@@ -5,6 +5,7 @@ gemspec
 
 gem 'kaminari', require: false
 gem 'will_paginate', require: false
+gem 'pagy', require: false
 
 gem 'sqlite3', require: false
 gem 'sequel', require: false

README.md

@@ -18,6 +18,7 @@ gem 'rails-api'
 gem 'grape', '>= 0.10.0'
 
 # Then choose your preferred paginator from the following:
+gem 'pagy'
 gem 'kaminari'
 gem 'will_paginate'
 
@@ -27,11 +28,11 @@ gem 'api-pagination'
 
 ## Configuration (optional)
 
-By default, api-pagination will detect whether you're using Kaminari or WillPaginate, and name headers appropriately. If you want to change any of the configurable settings, you may do so:
+By default, api-pagination will detect whether you're using Pagy, Kaminari, or WillPaginate, and it will name headers appropriately. If you want to change any of the configurable settings, you may do so:
 
 ```ruby
 ApiPagination.configure do |config|
-  # If you have both gems included, you can choose a paginator.
+  # If you have more than one gem included, you can choose a paginator.
   config.paginator = :kaminari # or :will_paginate
 
   # By default, this is set to 'Total'
@@ -59,6 +60,16 @@ ApiPagination.configure do |config|
 end
 ```
 
+### Pagy-specific configuration
+
+Pagy does not have a built-in way to specify a maximum number of items per page, but `api-pagination` will check if you've set a `:max_per_page` variable. To configure this, you can use the following code somewhere in an initializer:
+
+```ruby
+Pagy::VARS[:max_per_page] = 100
+```
+
+If left unconfigured, clients can request as many items per page as they wish, so it's highly recommended that you configure this.
+
 ## Rails
 
 In your controller, provide a pageable collection to the `paginate` method. In its most convenient form, `paginate` simply mimics `render`:
@@ -103,7 +114,7 @@ class MoviesController < ApplicationController
 end
 ```
 
-Note that the collection sent to `paginate` _must_ respond to your paginator's methods. This is typically fine unless you're dealing with a stock Array. For Kaminari, `Kaminari.paginate_array` will be called for you behind-the-scenes. For WillPaginate, you're out of luck unless you call `require 'will_paginate/array'` somewhere. Because this pollutes `Array`, it won't be done for you automatically.
+Note that the collection sent to `paginate` _must_ respond to your paginator's methods. This is typically fine unless you're dealing with a stock Array. For Kaminari, `Kaminari.paginate_array` will be called for you behind-the-scenes. For WillPaginate, you're out of luck unless you call `require 'will_paginate/array'` somewhere. Because this pollutes `Array`, it won't be done for you automatically. If you use Pagy, it doesn't matter, because Pagy doesn't care what you're paginating. It will just work, as long as the collection responds to `count`.
 
 **NOTE:** In versions 4.4.0 and below, the `Rails::Pagination` module would end up included in `ActionController::Base` even if `ActionController::API` was defined. As of version 4.5.0, this is no longer the case. If for any reason your API controllers cannot easily changed be changed to inherit from `ActionController::API` instead, you can manually include the module:
 

lib/api-pagination.rb

@@ -9,6 +9,8 @@ def paginate(collection, options = {})
       options[:per_page] = options[:per_page].to_i
 
       case ApiPagination.config.paginator
+      when :pagy
+        paginate_with_pagy(collection, options)
       when :kaminari
         paginate_with_kaminari(collection, options, options[:paginate_array_options] || {})
       when :will_paginate
@@ -18,7 +20,9 @@ def paginate(collection, options = {})
       end
     end
 
-    def pages_from(collection)
+    def pages_from(collection, options = {})
+      return pagy_pages_from(collection) if collection.is_a?(Pagy)
+
       {}.tap do |pages|
         unless collection.first_page?
           pages[:first] = 1
@@ -34,13 +38,49 @@ def pages_from(collection)
 
     def total_from(collection)
       case ApiPagination.config.paginator
+        when :pagy          then collection.count.to_s
         when :kaminari      then collection.total_count.to_s
         when :will_paginate then collection.total_entries.to_s
       end
     end
 
     private
 
+    def paginate_with_pagy(collection, options)
+      if Pagy::VARS[:max_per_page] && options[:per_page] > Pagy::VARS[:max_per_page]
+        options[:per_page] = Pagy::VARS[:max_per_page]
+      elsif options[:per_page] <= 0
+        options[:per_page] = Pagy::VARS[:items]
+      end
+
+      pagy = pagy_from(collection, options)
+      collection = if collection.respond_to?(:offset) && collection.respond_to?(:limit)
+        collection.offset(pagy.offset).limit(pagy.items)
+      else
+        collection[pagy.offset, pagy.items]
+      end
+
+      return [collection, pagy]
+    end
+
+    def pagy_from(collection, options)
+      Pagy.new(count: collection.count, items: options[:per_page], page: options[:page])
+    end
+
+    def pagy_pages_from(pagy)
+      {}.tap do |pages|
+        unless pagy.page == 1
+          pages[:first] = 1
+          pages[:prev]  = pagy.prev
+        end
+
+        unless pagy.page == pagy.pages
+          pages[:last] = pagy.pages
+          pages[:next] = pagy.next
+        end
+      end
+    end
+
     def paginate_with_kaminari(collection, options, paginate_array_options = {})
       if Kaminari.config.max_per_page && options[:per_page] > Kaminari.config.max_per_page
         options[:per_page] = Kaminari.config.max_per_page

lib/api-pagination/configuration.rb

@@ -55,6 +55,8 @@ def paginator
 
     def paginator=(paginator)
       case paginator.to_sym
+      when :pagy
+        use_pagy
       when :kaminari
         use_kaminari
       when :will_paginate
@@ -67,11 +69,12 @@ def paginator=(paginator)
     private
 
     def set_paginator
-      if defined?(Kaminari) && defined?(WillPaginate::CollectionMethods)
+      conditions = [defined?(Pagy), defined?(Kaminari), defined?(WillPaginate::CollectionMethods)]
+      if conditions.compact.size > 1
         Kernel.warn <<-WARNING
-Warning: api-pagination relies on either Kaminari or WillPaginate, but both are
-currently active. If possible, you should remove one or the other. If you can't,
-you _must_ configure api-pagination on your own. For example:
+Warning: api-pagination relies on Pagy, Kaminari, or WillPaginate, but more than
+one are currently active. If possible, you should remove one or the other. If
+you can't, you _must_ configure api-pagination on your own. For example:
 
 ApiPagination.configure do |config|
   config.paginator = :kaminari
@@ -86,13 +89,19 @@ def set_paginator
 end
 
 WARNING
+      elsif defined?(Pagy)
+        use_pagy
       elsif defined?(Kaminari)
-        return use_kaminari
+        use_kaminari
       elsif defined?(WillPaginate::CollectionMethods)
-        return use_will_paginate
+        use_will_paginate
       end
     end
 
+    def use_pagy
+      @paginator = :pagy
+    end
+
     def use_kaminari
       require 'kaminari/models/array_extension'
       @paginator = :kaminari

lib/api-pagination/hooks.rb

@@ -4,14 +4,16 @@
   Grape::API.send(:include, Grape::Pagination)
 end
 
+begin; require 'pagy';          rescue LoadError; end
 begin; require 'kaminari';      rescue LoadError; end
 begin; require 'will_paginate'; rescue LoadError; end
 
-unless defined?(Kaminari) || defined?(WillPaginate::CollectionMethods)
+unless defined?(Pagy) || defined?(Kaminari) || defined?(WillPaginate::CollectionMethods)
   Kernel.warn <<-WARNING.gsub(/^\s{4}/, '')
-    Warning: api-pagination relies on either Kaminari or WillPaginate. Please
-    install either dependency by adding one of the following to your Gemfile:
+    Warning: api-pagination relies on either Pagy, Kaminari, or WillPaginate.
+    Please install a paginator by adding one of the following to your Gemfile:
 
+    gem 'pagy'
     gem 'kaminari'
     gem 'will_paginate'
   WARNING

lib/grape/pagination.rb

@@ -9,11 +9,11 @@ def paginate(collection)
             :page     => ApiPagination.config.page_param(params),
             :per_page => [per_page, route_setting(:max_per_page)].compact.min
           }
-          collection = ApiPagination.paginate(collection, options)
+          collection, pagy = ApiPagination.paginate(collection, options)
 
           links = (header['Link'] || "").split(',').map(&:strip)
           url   = request.url.sub(/\?.*$/, '')
-          pages = ApiPagination.pages_from(collection)
+          pages = ApiPagination.pages_from(pagy || collection, options)
 
           pages.each do |k, v|
             old_params = Rack::Utils.parse_nested_query(request.query_string)
@@ -27,7 +27,7 @@ def paginate(collection)
           include_total   = ApiPagination.config.include_total
 
           header 'Link',          links.join(', ') unless links.empty?
-          header total_header,    ApiPagination.total_from(collection).to_s if include_total
+          header total_header,    ApiPagination.total_from(pagy || collection).to_s if include_total
           header per_page_header, options[:per_page].to_s
           header page_header,     options[:page].to_s unless page_header.nil?
 

lib/rails/pagination.rb

@@ -27,11 +27,11 @@ def _paginate_collection(collection, options={})
       options[:page] = ApiPagination.config.page_param(params)
       options[:per_page] ||= ApiPagination.config.per_page_param(params)
 
-      collection = ApiPagination.paginate(collection, options)
+      collection, pagy = ApiPagination.paginate(collection, options)
 
       links = (headers['Link'] || '').split(',').map(&:strip)
       url   = base_url + request.path_info
-      pages = ApiPagination.pages_from(collection)
+      pages = ApiPagination.pages_from(pagy || collection, options)
 
       pages.each do |k, v|
         new_params = request.query_parameters.merge(:page => v)
@@ -46,7 +46,7 @@ def _paginate_collection(collection, options={})
       headers['Link'] = links.join(', ') unless links.empty?
       headers[per_page_header] = options[:per_page].to_s
       headers[page_header] = options[:page].to_s unless page_header.nil?
-      headers[total_header] = total_count(collection, options).to_s if include_total
+      headers[total_header] = total_count(pagy || collection, options).to_s if include_total
 
       return collection
     end
@@ -62,6 +62,5 @@ def total_count(collection, options)
     def base_url
       ApiPagination.config.base_url || request.base_url
     end
-
   end
 end

spec/api-pagination_spec.rb

@@ -5,60 +5,48 @@
   let(:paginate_array_options) {{ total_count: 1000 }}
 
   describe "#paginate" do
-    context 'Using kaminari' do
-      before do
-        ApiPagination.config.paginator = :kaminari
-      end
-
-      after do
-        ApiPagination.config.paginator = ENV['PAGINATOR'].to_sym
-      end
-
-      it 'should accept paginate_array_options option' do
-        expect(Kaminari).to receive(:paginate_array)
-                              .with(collection, paginate_array_options)
-                              .and_call_original
-
-        ApiPagination.paginate(
-          collection,
-          {
-            per_page:               30,
-            paginate_array_options: paginate_array_options
-          }
-        )
-      end
+    if ENV['PAGINATOR'].to_sym == :kaminari
+      context 'Using kaminari' do
+        it 'should accept paginate_array_options option' do
+          expect(Kaminari).to receive(:paginate_array)
+                                .with(collection, paginate_array_options)
+                                .and_call_original
+
+          ApiPagination.paginate(
+            collection,
+            {
+              per_page:               30,
+              paginate_array_options: paginate_array_options
+            }
+          )
+        end
 
-      describe '.pages_from' do
-        subject {described_class.pages_from collection}
+        describe '.pages_from' do
+          subject {described_class.pages_from collection}
 
-        context 'on empty collection' do
-          let(:collection) {ApiPagination.paginate [], page: 1}
+          context 'on empty collection' do
+            let(:collection) {ApiPagination.paginate [], page: 1}
 
-          it {is_expected.to be_empty}
+            it {is_expected.to be_empty}
+          end
         end
       end
     end
 
-    context 'Using will_paginate' do
-      before do
-        ApiPagination.config.paginator = :will_paginate
-      end
-
-      after do
-        ApiPagination.config.paginator = ENV['PAGINATOR'].to_sym
-      end
-
-      context 'passing in total_entries in options' do
-        it 'should set total_entries using the passed in value' do
-          paginated_collection = ApiPagination.paginate(collection, total_entries: 3000)
-          expect(paginated_collection.total_entries).to eq(3000)
+    if ENV['PAGINATOR'].to_sym == :will_paginate
+      context 'Using will_paginate' do
+        context 'passing in total_entries in options' do
+          it 'should set total_entries using the passed in value' do
+            paginated_collection = ApiPagination.paginate(collection, total_entries: 3000)
+            expect(paginated_collection.total_entries).to eq(3000)
+          end
         end
-      end
 
-      context 'passing in collection only' do
-        it 'should set total_entries using the size of the collection ' do
-          paginated_collection = ApiPagination.paginate(collection)
-          expect(paginated_collection.total_entries).to eq(100)
+        context 'passing in collection only' do
+          it 'should set total_entries using the size of the collection ' do
+            paginated_collection = ApiPagination.paginate(collection)
+            expect(paginated_collection.total_entries).to eq(100)
+          end
         end
       end
     end