Merge branch 'master' into fix-detect-model

Author: mach-kernel

.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,8 @@ gemspec
 
 gem 'kaminari', require: false
 gem 'will_paginate', require: false
+gem 'pagy', require: false
 
 gem 'sqlite3', require: false
 gem 'sequel', require: false
+gem 'pry-suite'

README.md

@@ -1,7 +1,5 @@
 # api-pagination
 
-[![Build Status][travis-badge]][travis] [![Coverage][coveralls-badge]][coveralls] [![Climate][code-climate-badge]][code-climate] [![Dependencies][gemnasium-badge]][gemnasium] [![gittip][gittip-badge]][gittip]
-
 Paginate in your headers, not in your response body.
 This follows the proposed [RFC-5988](http://tools.ietf.org/html/rfc5988) standard for Web linking.
 
@@ -18,6 +16,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 +26,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 +58,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 +112,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:
 

api-pagination.gemspec

@@ -18,8 +18,8 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'grape', '>= 0.10.0'
-  s.add_development_dependency 'railties', '>= 3.0.0'
-  s.add_development_dependency 'actionpack', '>= 3.0.0'
+  s.add_development_dependency 'railties', '>= 5.0.0'
+  s.add_development_dependency 'actionpack', '>= 5.0.0'
   s.add_development_dependency 'sequel', '>= 4.9.0'
   s.add_development_dependency 'activerecord-nulldb-adapter', '>= 0.3.8'
 end

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
@@ -49,21 +89,23 @@ def paginate_with_kaminari(collection, options, paginate_array_options = {})
       end
 
       collection = Kaminari.paginate_array(collection, paginate_array_options) if collection.is_a?(Array)
-      collection.page(options[:page]).per(options[:per_page])
+      [collection.page(options[:page]).per(options[:per_page]), nil]
     end
 
     def paginate_with_will_paginate(collection, options)
       if options[:per_page] <= 0
         options[:per_page] = default_per_page_for_will_paginate(collection)
       end
 
-      if defined?(Sequel::Dataset) && collection.kind_of?(Sequel::Dataset)
+      collection = if defined?(Sequel::Dataset) && collection.kind_of?(Sequel::Dataset)
         collection.paginate(options[:page], options[:per_page])
       else
         supported_options = [:page, :per_page, :total_entries]
         options = options.dup.keep_if { |k,v| supported_options.include?(k.to_sym) }
         collection.paginate(options)
       end
+
+      [collection, nil]
     end
 
     def get_default_per_page_for_kaminari(collection)

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

@@ -1,42 +1,36 @@
-begin; require 'rails'; rescue LoadError; end
-begin; require 'rails-api'; rescue LoadError; end
-
-if defined?(Rails)
-  module ApiPagination
-    module Hooks
-      def self.rails_parent_controller
-        if Gem::Version.new(Rails.version) >= Gem::Version.new('5') || defined?(ActionController::API)
-          ActionController::API
-        else
-          ActionController::Base
-        end
-      end
-    end
-  end
-
-  require 'rails/pagination'
-
-  ActiveSupport.on_load(:action_controller) do
-    ApiPagination::Hooks.rails_parent_controller.send(:include, Rails::Pagination)
-  end
-end
-
 begin; require 'grape'; rescue LoadError; end
 if defined?(Grape::API)
   require 'grape/pagination'
   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
 end
 
+if defined?(Rails)
+  module ApiPagination
+    module Hooks
+      def self.rails_parent_controller
+        if Rails::VERSION::MAJOR >= 5 || defined?(ActionController::API)
+          ActionController::API
+        else
+          ActionController::Base
+        end
+      end
+    end
+  end
+
+  require 'api-pagination/railtie'
+end

lib/api-pagination/railtie.rb

@@ -0,0 +1,19 @@
+require 'rails/railtie'
+
+module ApiPagination
+  class Railtie < ::Rails::Railtie
+    initializer :api_pagination do
+      ActiveSupport.on_load(:action_controller) do
+        require 'rails/pagination'
+
+        klass = if Rails::VERSION::MAJOR >= 5 || defined?(ActionController::API)
+          ActionController::API
+        else
+          ActionController::Base
+        end
+
+        klass.send(:include, Rails::Pagination)
+      end
+    end
+  end
+end

lib/api-pagination/version.rb

@@ -1,8 +1,8 @@
 module ApiPagination
   class Version
     MAJOR = 4
-    MINOR = 7
-    PATCH = 1
+    MINOR = 8
+    PATCH = 0
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

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?