api-pagination 4.7.2 → 4.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcd1a8e55bce363ef14c8fca2ff4a06ea1cf325e61fe2eba564d6bcbcb0cbb43
-  data.tar.gz: 66a8a77cc4e1fa163ce3e644c2828388778efaab24783967c2c9e7986a83ac30
+  metadata.gz: 9027303d9da656103e61812aded61149a601a27dbc398d40d44d2952242fbb6d
+  data.tar.gz: 5758331c124689a6160d6b787409bb8abfbba83213e201289c227f624afe7db5
 SHA512:
-  metadata.gz: 475209b5986a009d9bc52cded5269fec22998e6d94c419635772950ee17ea7a1b0a01818b6791f009fe9da545022522f2ba0303a5fae93d81a364f3bc740cb1e
-  data.tar.gz: 355d8e7786bf49318941d48ea57ff6fd81fd6cf9b97d9e185fb1302eb20dc4144100f3fce675809d73bffc0341b0f100e37fb3f12a2e6c51ea9b98e4d9db5a03
+  metadata.gz: 7ae4651a31cfbe45a02ffc9da7376c30ef5400d30265528de8f39130924fbef327d7158aedfe21fe7c24899c3632a14161bfc4392f8ab69fc167c21d4de608be
+  data.tar.gz: 842bb2e7b03046cbacfbfed1dc8ea6c4ebc435f7a91423d98f844dde5a2128573cd21bda81d5813a8e813abfb0154f22e0fc0436033923ddd4af04f96888f0ea

data/lib/api-pagination.rb

@@ -9,6 +9,8 @@ module ApiPagination
       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 @@ module ApiPagination
       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,6 +38,7 @@ module ApiPagination
 
     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
@@ -41,6 +46,41 @@ module ApiPagination
 
     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,7 +89,7 @@ module ApiPagination
       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)
@@ -57,13 +97,15 @@ module ApiPagination
         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)

data/lib/api-pagination/configuration.rb

@@ -55,6 +55,8 @@ module ApiPagination
 
     def paginator=(paginator)
       case paginator.to_sym
+      when :pagy
+        use_pagy
       when :kaminari
         use_kaminari
       when :will_paginate
@@ -67,11 +69,12 @@ module ApiPagination
     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 @@ Kaminari.configure do |config|
 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

data/lib/api-pagination/hooks.rb

@@ -4,14 +4,16 @@ if defined?(Grape::API)
   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

data/lib/api-pagination/version.rb

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

data/lib/grape/pagination.rb

@@ -9,11 +9,11 @@ module Grape
             :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 @@ module Grape
           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?
 

data/lib/rails/pagination.rb

@@ -27,11 +27,11 @@ module Rails
       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 @@ module Rails
       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 @@ module Rails
     def base_url
       ApiPagination.config.base_url || request.base_url
     end
-
   end
 end

data/spec/api-pagination_spec.rb

@@ -5,60 +5,48 @@ describe ApiPagination do
   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).first }
 
-          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).first
+            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).first
+            expect(paginated_collection.total_entries).to eq(100)
+          end
         end
       end
     end

data/spec/rails_spec.rb

@@ -214,8 +214,11 @@ describe NumbersController, :type => :controller do
       end
     end
 
-    context 'paginate array options' do
-      shared_examples 'properly set Total header' do
+    if ApiPagination.config.paginator.to_sym == :kaminari
+      context 'paginate array options' do
+        let(:paginate_array_total_count) { 300 }
+        let(:total_header) { 300 }
+        let(:count) { 50 }
         let(:params) do
           {
             paginate_array_total_count: paginate_array_total_count,
@@ -223,84 +226,57 @@ describe NumbersController, :type => :controller do
           }
         end
 
-        specify do
+        it 'has a properly set Total header' do
           get :index_with_paginate_array_options, params: params
 
           expect(response.header['Total']).to be_kind_of(String)
           expect(response.header['Total'].to_i).to eq total_header
         end
       end
-
-      context 'kaminari' do
-        around do |example|
-          paginator = ApiPagination.config.paginator
-          ApiPagination.config.paginator = :kaminari
-          example.run
-          ApiPagination.config.paginator = paginator
-        end
-
-        it_should_behave_like 'properly set Total header' do
-          let(:paginate_array_total_count) { 300 }
-          let(:total_header) { 300 }
-          let(:count) { 50 }
-        end
-      end
-
-      context 'will_paginate' do
-        around do |example|
-          paginator = ApiPagination.config.paginator
-          ApiPagination.config.paginator = :will_paginate
-          example.run
-          ApiPagination.config.paginator = paginator
-        end
-
-        it_should_behave_like 'properly set Total header' do
-          let(:paginate_array_total_count) { 300 }
-          let(:total_header) { 50 }
-          let(:count) { 50 }
-        end
-      end
     end
 
-    context 'default per page in model' do
-      before do
-        class Fixnum
-          @default_per_page = 6
-          @per_page = 6
+    if [:will_paginate, :kaminari].include?(ApiPagination.config.paginator.to_sym)
+      context 'default per page in model' do
+        before do
+          class Fixnum
+            @default_per_page = 6
+            @per_page = 6
 
-          class << self
-            attr_accessor :default_per_page, :per_page
+            class << self
+              attr_accessor :default_per_page, :per_page
+            end
           end
         end
-      end
 
-      after do
-        class Fixnum
-          @default_per_page = 25
-          @per_page = 25
+        after do
+          class Fixnum
+            @default_per_page = 25
+            @per_page = 25
+          end
         end
-      end
 
-      it 'should use default per page from model' do
-        get :index_with_no_per_page, params: {count: 100}
+        it 'should use default per page from model' do
+          get :index_with_no_per_page, params: {count: 100}
 
-        expect(response.header['Per-Page']).to eq('6')
-      end
-
-      it 'should not fail if model does not respond to per page' do
-        class Fixnum
-          @default_per_page = nil
-          @per_page = nil
+          expect(response.header['Per-Page']).to eq('6')
         end
 
-        get :index_with_no_per_page, params: {count: 100}
-
-        expect(response.header['Per-Page']).to eq(
-          case ApiPagination.config.paginator
-          when :kaminari      then Kaminari.config.default_per_page.to_s
-          when :will_paginate then WillPaginate.per_page.to_s
+        it 'should not fail if model does not respond to per page' do
+          class Fixnum
+            @default_per_page = nil
+            @per_page = nil
           end
-        )
+
+          get :index_with_no_per_page, params: {count: 100}
+
+          expect(response.header['Per-Page']).to eq(
+            case ApiPagination.config.paginator
+            when :pagy          then Pagy::VARS[:items].to_s
+            when :kaminari      then Kaminari.config.default_per_page.to_s
+            when :will_paginate then WillPaginate.per_page.to_s
+            end
+          )
+        end
       end
     end
   end

data/spec/sequel_spec.rb

@@ -23,9 +23,8 @@ if ApiPagination.config.paginator == :will_paginate
     end
 
     it 'returns a Sequel::Dataset' do
-      collection = ApiPagination.paginate(people)
+      collection = ApiPagination.paginate(people).first
       expect(collection.kind_of?(Sequel::Dataset)).to be_truthy
     end
   end
 end
-

data/spec/spec_helper.rb

@@ -3,14 +3,20 @@ require 'support/numbers_api'
 require 'api-pagination'
 
 if ENV['PAGINATOR'].nil?
-  warn 'No PAGINATOR set. Defaulting to kaminari. To test against will_paginate, run `PAGINATOR=will_paginate bundle exec rspec`'
-  ENV['PAGINATOR'] = 'kaminari'
+  warn <<-WARNING
+No PAGINATOR set. Defaulting to pagy.
+
+To test against kaminari, run `PAGINATOR=kaminari bundle exec rspec`
+To test against will_paginate, run `PAGINATOR=will_paginate bundle exec rspec`
+WARNING
+
+  ENV['PAGINATOR'] = 'pagy'
 end
 
 require ENV['PAGINATOR']
 ApiPagination.config.paginator = ENV['PAGINATOR'].to_sym
 
-require 'will_paginate/array'
+require 'will_paginate/array' if ENV['PAGINATOR'].to_sym == :will_paginate
 
 RSpec.configure do |config|
   config.include Rack::Test::Methods

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api-pagination
 version: !ruby/object:Gem::Version
-  version: 4.7.2
+  version: 4.8.0
 platform: ruby
 authors:
 - David Celis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-08 00:00:00.000000000 Z
+date: 2018-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec