Extract shared code

Signed-off-by: David Celis <[email protected]>

Author: davidcelis

README.md

@@ -7,9 +7,10 @@ Put pagination info in a Link header, not the response body.
 In your `Gemfile`:
 
 ```ruby
-# Requires Rails and is compatible with Rails-API.
+# Requires Rails (Rails-API is also supported) or Grape.
 gem 'rails', '>= 3.0.0'
-# gem 'rails-api'
+gem 'rails-api'
+gem 'grape'
 
 # Then choose your preferred paginator from the following:
 gem 'kaminari'
@@ -19,33 +20,57 @@ gem 'will_paginate'
 gem 'api-pagination'
 ```
 
-## Usage
+## Rails
 
-In your controllers:
+In your controller:
 
 ```ruby
 class MoviesController < ApplicationController
-  # Uses the @movies and @actors variables set below
+  # Uses the @movies and @actors variables set below.
+  # This method must take an ActiveRecord::Relation
+  # or some equivalent pageable set.
   after_filter only: [:index] { paginate(:movies) }
   after_filter only: [:cast]  { paginate(:actors) }
 
   # GET /movies
   def index
-    @movies = Movie.page(params[:page])
+    @movies = Movie.scoped
 
     render json: @movies
   end
 
   # GET /movies/:id/cast
   def cast
     @movie  = Movie.find(params[:id])
-    @actors = @movie.actors.page(params[:page])
+    @actors = @movie.actors
+
+    # Override how many Actors get returned.
+    params[:per_page] = 10
 
     render json: @actors
   end
 end
 ```
 
+## Grape
+
+In your API endpoint:
+
+```ruby
+class MoviesAPI < Grape::API
+  format :json
+
+  desc 'Return a paginated set of movies'
+  paginate per_page: 25
+  get :numbers do
+    movies = Movie.scoped
+
+    # This method must take an ActiveRecord::Relation
+    # or some equivalent pageable set.
+    paginate movies
+  end
+end
+
 Then `curl --include` to see your Link header pagination in action:
 
 ```bash

lib/api-pagination.rb

@@ -1,4 +1,39 @@
 require 'api-pagination/hooks'
 require 'api-pagination/version'
 
+module ApiPagination
+  class << self
+    attr_writer :kaminari
+    attr_writer :will_paginate
+
+    def kaminari?() !!@kaminari end
+    def will_paginate?() !!@will_paginate end
+
+    def paginate(collection, options = {}, &block)
+      options[:page]     ||= 1
+      options[:per_page] ||= 10
+
+      if ApiPagination.kaminari?
+        collection.page(options[:page]).per(options[:per_page]).tap(&block)
+      elsif ApiPagination.will_paginate?
+        collection.paginate(:page => options[:page], :per_page => options[:per_page]).tap(&block)
+      end
+    end
+
+    def pages_from(collection)
+      {}.tap do |pages|
+        unless collection.first_page?
+          pages[:first] = 1
+          pages[:prev]  = collection.current_page - 1
+        end
+
+        unless collection.last_page?
+          pages[:last] = collection.total_pages
+          pages[:next] = collection.current_page + 1
+        end
+      end
+    end
+  end
+end
+
 ApiPagination::Hooks.init

lib/api-pagination/hooks.rb

@@ -25,9 +25,14 @@ def self.init
           def first_page?() !previous_page end
           def last_page?() !next_page end
         end
+
+        ApiPagination.will_paginate = true
       end
 
       begin; require 'kaminari'; rescue LoadError; end
+      if defined?(Kaminari)
+        ApiPagination.kaminari = true
+      end
 
       STDERR.puts <<-EOC unless defined?(Kaminari) || defined?(WillPaginate)
 Warning: api-pagination relies on either Kaminari or WillPaginate. Please

lib/grape/pagination.rb

@@ -3,21 +3,10 @@ module Pagination
     def self.included(base)
       Grape::Endpoint.class_eval do
         def paginate(collection)
-          collection.page(params[:page]).per(params[:per_page]).tap do |scope|
+          block = Proc.new do |collection|
             links = (header['Link'] || "").split(',').map(&:strip)
-
             url   = request.url.sub(/\?.*$/, '')
-            pages = {}
-
-            unless scope.first_page?
-              pages[:first] = 1
-              pages[:prev]  = scope.current_page - 1
-            end
-
-            unless scope.last_page?
-              pages[:last] = scope.total_pages
-              pages[:next] = scope.current_page + 1
-            end
+            pages = ApiPagination.pages_from(collection)
 
             pages.each do |k, v|
               old_params = Rack::Utils.parse_query(request.query_string)
@@ -27,6 +16,8 @@ def paginate(collection)
 
             header 'Link', links.join(', ') unless links.empty?
           end
+
+          ApiPagination.paginate(collection, params, &block)
         end
       end
 

lib/rails/pagination.rb

@@ -2,31 +2,23 @@ module Rails
   module Pagination
     protected
 
-      def paginate(scope)
-        links = (headers['Link'] || "").split(',').map(&:strip)
+      def paginate(collection)
+        collection = instance_variable_get(:"@#{collection}")
 
-        scope = instance_variable_get(:"@#{scope}")
-        url   = request.original_url.sub(/\?.*$/, '')
-        pages = {}
+        block = Proc.new do |collection|
+          links = (headers['Link'] || "").split(',').map(&:strip)
+          url   = request.original_url.sub(/\?.*$/, '')
+          pages = ApiPagination.pages_from(collection)
 
-        unless scope.first_page?
-          pages[:first] = 1
-          pages[:prev]  = scope.current_page - 1
-        end
-
-        unless scope.last_page?
-          pages[:last] = scope.total_pages
-          pages[:next] = scope.current_page + 1
-        end
+          pages.each do |k, v|
+            new_params = request.query_parameters.merge(:page => v)
+            links << %(<#{url}?#{new_params.to_param}>; rel="#{k}")
+          end
 
-        pages.each do |k, v|
-          new_params = request.query_parameters.merge(:page => v)
-          links << %(<#{url}?#{new_params.to_param}>; rel="#{k}")
+          headers['Link'] = links.join(', ') unless links.empty?
         end
 
-        headers['Link'] = links.join(', ') unless links.empty?
-
-        return scope
+        ApiPagination.paginate(collection, params, &block)
       end
   end
 end

spec/spec_helper.rb

@@ -3,7 +3,9 @@
 require 'api-pagination'
 require 'support/numbers_api'
 
-# Quacks like Kaminari
+ApiPagination.kaminari = true
+
+# Quacks like Kaminari and will_paginate
 PaginatedSet = Struct.new(:current_page, :per_page, :total_count) do
   def total_pages
     total_count.zero? ? 1 : (total_count.to_f / per_page).ceil
@@ -21,6 +23,10 @@ def per(per)
     per_page = per
     self
   end
+
+  def paginate(options = {})
+    page(options[:page]).per(options[:per_page])
+  end
 end
 
 RSpec.configure do |config|