pagoid 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+db/
+*.db

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+pagoid

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p327

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pagoid.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jon Phenow
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# Pagoid
+
+Pagoid extracts the difference between [WillPaginate](https://github.com/mislav/will_paginate) and
+[Kaminari](https://github.com/amatsuda/kaminari) as well as provides a standard callback
+for things like publishing page info to your clients.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kaminari'
+# OR
+gem 'will_paginate'
+
+gem 'pagoid'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+## Usage
+
+```ruby
+class PeopleController < ApplicationController
+  paged do |pager|
+    metadata[:paging] = pager.headers if pager.display_headers?
+  end
+
+  def index
+    @people = paginated Person
+    render json: { metadata: metdata, result: @people }
+  end
+
+  private
+  def metadata
+    @metdata ||= {}
+  end
+end
+```
+
+You can stack `paged` blocks through inheritance:
+
+```ruby
+class ApplicationController < ActionController::Base
+  paged do |pager|
+    notice! pager.headers
+  end
+
+  def notice!(hash)
+    Rails.logger.debug hash
+  end
+end
+
+class PeopleController < ApplicationController
+  #.. from above
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/pagoid.rb

@@ -0,0 +1,21 @@
+require "pagoid/version"
+begin
+  require 'kaminari'
+  require 'kaminari/models/array_extension'
+  if defined?(ActiveRecord::Base)
+    require 'kaminari/models/active_record_extension'
+    ::ActiveRecord::Base.send :include, Kaminari::ActiveRecordExtension
+  end
+rescue LoadError
+  begin
+    require 'will_paginate'
+    require 'will_paginate/array'
+  rescue LoadError
+    raise LoadError, "Please install kaminari or will_paginate for Pagoid backends"
+  end
+end
+
+require 'pagoid/pager'
+require 'pagoid/controller_extensions'
+require 'pagoid/adapter_router'
+require 'pagoid/engine' if defined?(Rails)

data/lib/pagoid/adapter_router.rb

@@ -0,0 +1,58 @@
+require 'pagoid/paging_adapter'
+module Pagoid
+  class AdapterRouter
+    private
+    attr_accessor :pageable
+
+    def initialize(pageable)
+      self.pageable = pageable
+    end
+
+    public
+
+    def route
+      chosen_adapter = configured || route_table.find { |routeable| useable? routeable }
+      raise RouterError, "Could not find a suitable Pagoid Adapter" unless chosen_adapter
+      load_dependencies chosen_adapter
+      constantize(pagoided(chosen_adapter)).new pageable
+    end
+
+    private
+
+    def configured
+    end
+
+    def pagoided(adapter)
+      "::Pagoid::#{adapter}"
+    end
+
+    def load_dependencies(adapter)
+      require "pagoid/#{underscore(adapter)}"
+    end
+
+    def underscore(adapter_name)
+      adapter_name.gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+      .tr("-", "_")
+      .downcase
+    end
+
+    def useable?(adapter)
+      constantize "::#{adapter}"
+    rescue NameError
+      false
+    end
+
+    def constantize(adapter)
+      Object.module_eval(adapter)
+    end
+
+    def route_table
+      %w[
+        Kaminari
+        WillPaginate
+      ]
+    end
+  end
+end

data/lib/pagoid/controller_extensions.rb

@@ -0,0 +1,33 @@
+module Pagoid
+  module ControllerExtensions
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def paginated(resource)
+      pager = Pager.new(resource, params)
+      self.class.apply_pager_blocks(self, pager)
+      pager.paginated
+    end
+
+    module ClassMethods
+      def paged(&block)
+        @pagination_block = block
+      end
+
+      def apply_pager_blocks(context, pager_instance)
+        pager_blocks.each { |block| context.instance_exec(pager_instance, &block) }
+      end
+
+      def pager_block
+        @pagination_block || ->(x) { x }
+      end
+      private :pager_block
+
+      def pager_blocks
+        [pager_block] + (superclass.respond_to?(:pager_blocks) ? superclass.pager_blocks : [])
+      end
+      protected :pager_blocks
+    end
+  end
+end

data/lib/pagoid/engine.rb

@@ -0,0 +1,10 @@
+require 'rails/engine'
+module Pagoid
+  class Engine < Rails::Engine
+    initializer 'pagoid.engine' do |app|
+      ActiveSupport.on_load(:action_controller) do
+        include Pagoid::ControllerExtensions
+      end
+    end
+  end
+end

data/lib/pagoid/kaminari.rb

@@ -0,0 +1,22 @@
+require 'pagoid/paging_adapter'
+module Pagoid
+  class Kaminari < PagingAdapter
+    def coerce(coerceable = paginatable)
+      coerce?(coerceable) ? ::Kaminari.paginate_array(Array(coerceable)) : coerceable
+    end
+
+    def page(*args)
+      __getobj__.page(*args)
+    end
+
+    private
+
+    def coerce?(coerceable = paginatable)
+      !(
+        coerceable.respond_to?(:order) &&
+        coerceable.respond_to?(:page) &&
+        coerceable.page.respond_to?(:per)
+      )
+    end
+  end
+end

data/lib/pagoid/pager.rb

@@ -0,0 +1,123 @@
+require 'forwardable'
+# Service Class for handling of adapting paging for both Arrays and ActiveRecord objects.
+# An array of AR Objects should come out the same as if you were to pass in a relation (though
+# likely much slower).
+#
+# Defaults:
+#   page: 1
+#   per_page: 100
+#   order_by: Object <=> Object
+#   direction: Descending
+module Pagoid
+  class Pager
+    extend Forwardable
+    def_delegators :paginatable, :coerce
+
+    # Initialize
+    #
+    # @param [Object] paginatable Some object(like an Array or ActiveRecord Object) for pagination
+    # @param [Hash] options options hash for tweaking pagination
+    # @option options [Fixnum] :page The page number
+    # @option options [Fixnum] :per_page The page size
+    # @option options [Fixnum] :order_by Callable on each element (or column) to sort by
+    # @option options [Fixnum] :direction "desc" or "asc"
+    def initialize(paginatable, options = {})
+      self.paginatable = AdapterRouter.new(paginatable).route
+      self.options = options.dup
+    end
+
+    # Memoized method of Paged, Sized, and Ordered output
+    #
+    # @return ordered, sized, paged data
+    def paginated
+      @paginated ||= pered
+    end
+
+    # Hash of data for publishing on a payload for Paging reference
+    #
+    # @return [Hash] hash of paging data
+    def headers
+      {
+        total: paginated.total_count,
+        total_pages: paginated.total_pages,
+        first_page: paginated.first_page?,
+        last_page: paginated.last_page?,
+        current_page: paginated.current_page,
+        limit: paginated.limit_value,
+        offset: paginated.offset_value
+      }
+    end
+
+    # Describes whether or not to publish paging reference
+    #
+    # @return boolean describing whether to display pagination headers
+    def display_headers?
+      !paginated.nil?
+    end
+
+    private
+
+    attr_accessor :paginatable
+    attr_accessor :options
+
+    def pered
+      paged.per(per_page)
+    end
+
+    def ordered
+      coerce(order_callable.call(paginatable))
+    end
+
+    def paged
+      ordered.page(page)
+    end
+
+    def per_page
+      options[:per_page].to_i > 0 ? options[:per_page].to_i : 100
+    end
+
+    def order_callable
+      order_method_hash[order_method] || sort_proc || ->(o) { o }
+    end
+
+    def order_method
+      order_methods.find { |method| coerce.respond_to? method }
+    end
+
+    def order_method_hash
+      {
+        order: ->(orderable) { orderable.order "#{order_by} #{direction}" }
+      }
+    end
+
+    def sort_proc
+      if coerce.respond_to?(:sort)
+        ->(orderable) {
+          orderable.sort { |a,b|
+            direction == :asc ? order_by_value(a) <=> order_by_value(b) : order_by_value(b) <=> order_by_value(a)
+          }
+        }
+      end
+    end
+
+    def order_by_value(orderable)
+      orderable.respond_to?(order_by) ? orderable.public_send(order_by) : orderable
+    end
+
+    def order_methods
+      order_method_hash.keys
+    end
+
+    def page
+      options[:page].to_i > 0 ? options[:page].to_i : 1
+    end
+
+    def order_by
+      (!options[:order_by].nil? ? options[:order_by] : :created_at).to_s
+    end
+
+    def direction
+      options[:direction].to_s == "asc" ? :asc : :desc
+    end
+  end
+end

data/lib/pagoid/paging_adapter.rb

@@ -0,0 +1,27 @@
+require 'delegate'
+module Pagoid
+  class PagingAdapter < SimpleDelegator
+    attr_accessor :paginatable
+    attr_accessor :attributes
+
+    def initialize(paginatable, attributes = {})
+      self.paginatable = paginatable
+      self.attributes = attributes
+      super coerce
+    end
+
+    def coerce(coerceable = paginatable)
+      coerceable
+    end
+
+    %w[page per order].each do |meth|
+      define_method(meth) do |*args|
+        chain(super(*args))
+      end
+    end
+
+    def chain(object, state = {})
+      self.class.new object, state
+    end
+  end
+end

data/lib/pagoid/version.rb

@@ -0,0 +1,3 @@
+module Pagoid
+  VERSION = "0.0.1"
+end

data/lib/pagoid/will_paginate.rb

@@ -0,0 +1,50 @@
+require 'pagoid/paging_adapter'
+module Pagoid
+  class WillPaginate < PagingAdapter
+    def total_count
+      count
+    end
+
+    def limit_value
+      per_page
+    end
+
+    def offset_value
+      offset
+    end
+
+    def page(num)
+      if array?
+        chain __getobj__.paginate(page: num), original: __getobj__, page: num
+      else
+        chain super
+      end
+    end
+
+    def per(num)
+      if array?
+        chain per_object.paginate(page: attributes[:page], per_page: num)
+      else
+        chain __getobj__.per_page(num)
+      end
+    end
+
+    def first_page?
+      current_page == 1
+    end
+
+    def last_page?
+      current_page == total_pages
+    end
+
+    private
+
+    def per_object
+      attributes[:original] || __getobj__
+    end
+
+    def array?
+      __getobj__.respond_to? :paginate
+    end
+  end
+end

data/pagoid.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pagoid/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pagoid"
+  spec.version       = Pagoid::VERSION
+  spec.authors       = ["Jon Phenow"]
+  spec.email         = ["j.phenow@gmail.com"]
+  spec.description   = %q{Standardize paging abstraction}
+  spec.summary       = %q{Easy way to paginate with will_paginate or kaminari backends}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "kaminari"
+  spec.add_development_dependency "will_paginate"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "simplecov"
+end

data/spec/lib/pagoid/kaminari_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'pagoid/kaminari'
+require 'kaminari'
+require 'kaminari/models/array_extension'
+module Pagoid
+  describe Kaminari do
+    subject { described_class.new decorated }
+    before do
+      AdapterRouter.any_instance.stub configured: "Kaminari"
+    end
+
+    let(:decorated) { [] }
+
+    it_should_behave_like "a pager adapter"
+
+    its(:coerce) { should be_a ::Kaminari::PaginatableArray }
+
+    describe "with active record" do
+      let(:decorated) { Person }
+
+      its(:coerce) { should == Person }
+    end
+  end
+end

data/spec/lib/pagoid/pager_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+module Pagoid
+  describe Pager do
+    describe "array paging" do
+      let(:paginatable) { (1..10).to_a }
+      let(:options) { {} }
+      subject { described_class.new paginatable, options }
+
+      its(:paginated) { should == paginatable.reverse }
+      its(:display_headers?) { should be_true }
+
+      describe "with options" do
+        let(:options) { { per_page: per_page, page: page } }
+        let(:per_page) { 2 }
+        let(:page) { 1 }
+
+        its(:paginated) { should == [10,9] }
+        its(:display_headers?) { should be_true }
+
+        describe "sorting" do
+          let(:options) { { per_page: per_page, page: page, order_by: :to_s } }
+
+          its(:paginated) { should == [9,8] }
+          its(:display_headers?) { should be_true }
+
+          describe "with paging" do
+            let(:page) { 3 }
+
+            its(:paginated) { should == [5,4] }
+            its(:display_headers?) { should be_true }
+
+            describe "with direction" do
+              let(:page) { nil }
+              let(:options) { { per_page: per_page, page: page, order_by: :to_s, direction: "asc" } }
+
+              its(:paginated) { should == [1,10] }
+              its(:display_headers?) { should be_true }
+            end
+          end
+        end
+      end
+    end
+
+    describe "ActiveRecord paging" do
+      before do
+        %w[Adam Jon Mike Pat].each do |name|
+          Person.create(name: name)
+        end
+      end
+
+      let(:paginatable) { Person }
+      let(:options) { {} }
+      subject { described_class.new paginatable, options }
+
+      its(:paginated) { should == paginatable.order("created_at desc").all }
+      its(:display_headers?) { should be_true }
+
+      describe "with options" do
+        let(:options) { { per_page: per_page, page: page } }
+        let(:per_page) { 2 }
+        let(:page) { 1 }
+
+        its(:paginated) { should == Person.order("created_at desc").page(page).per(per_page) }
+        its(:display_headers?) { should be_true }
+
+        describe "sorting" do
+          let(:options) { { per_page: per_page, page: page, order_by: :name } }
+
+          its(:paginated) { should == Person.order("#{options[:order_by]} desc").page(page).per(per_page) }
+          its(:display_headers?) { should be_true }
+
+          describe "with paging" do
+            let(:page) { 2 }
+
+            its(:paginated) {
+              should == Person.page(page).per(options[:per_page]).order("#{options[:order_by]} desc")
+            }
+            its(:display_headers?) { should be_true }
+
+            describe "with direction" do
+              let(:page) { nil }
+              let(:options) { { per_page: per_page, page: page, order_by: :name, direction: "asc" } }
+
+              its(:paginated) { should == Person.order("name ASC").first(2) }
+              its(:display_headers?) { should be_true }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pagoid/will_paginate_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'pagoid/will_paginate'
+require 'will_paginate'
+require 'will_paginate/array'
+module Pagoid
+  describe WillPaginate do
+    subject { described_class.new decorated }
+    before do
+      AdapterRouter.any_instance.stub configured: "WillPaginate"
+    end
+
+    let(:decorated) { [] }
+
+    it_should_behave_like "a pager adapter"
+
+    describe "with active record" do
+      let(:decorated) { Person }
+
+      its(:coerce) { should == Person }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'active_record'
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+require 'pagoid'
+
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.before { Person.delete_all }
+
+  # --seed 1234
+  config.order = 'random'
+end

data/spec/support/adapter_shared_example.rb

@@ -0,0 +1,28 @@
+shared_examples "a specific page adaptation" do
+  it { should respond_to :page }
+  it { should respond_to :coerce }
+
+  describe "post-page methods" do
+    subject { described_class.new(decorated).page(1).per(1) }
+    it { should respond_to :total_count }
+    it { should respond_to :total_pages }
+    it { should respond_to :first_page? }
+    it { should respond_to :last_page? }
+    it { should respond_to :current_page }
+    it { should respond_to :limit_value }
+    it { should respond_to :offset_value }
+  end
+end
+
+shared_examples "a pager adapter" do
+  subject { described_class.new decorated }
+  let(:decorated) { [] }
+
+  it_should_behave_like "a specific page adaptation"
+
+  describe "with active record" do
+    let(:decorated) { Person }
+
+    it_should_behave_like "a specific page adaptation"
+  end
+end

data/spec/support/person.rb

@@ -0,0 +1,15 @@
+root = File.expand_path File.join(__FILE__, "../../../")
+ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3",
+  database: "#{root}/spec/support/pagoid.db"
+)
+
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'people'")
+
+ActiveRecord::Base.connection.create_table(:people) do |t|
+  t.string :name
+  t.timestamps
+end
+
+class Person < ActiveRecord::Base
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: pagoid
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jon Phenow
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: will_paginate
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Standardize paging abstraction
+email:
+- j.phenow@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pagoid.rb
+- lib/pagoid/adapter_router.rb
+- lib/pagoid/controller_extensions.rb
+- lib/pagoid/engine.rb
+- lib/pagoid/kaminari.rb
+- lib/pagoid/pager.rb
+- lib/pagoid/paging_adapter.rb
+- lib/pagoid/version.rb
+- lib/pagoid/will_paginate.rb
+- pagoid.gemspec
+- spec/lib/pagoid/kaminari_spec.rb
+- spec/lib/pagoid/pager_spec.rb
+- spec/lib/pagoid/will_paginate_spec.rb
+- spec/spec_helper.rb
+- spec/support/adapter_shared_example.rb
+- spec/support/person.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1133189516884409261
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1133189516884409261
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Easy way to paginate with will_paginate or kaminari backends
+test_files:
+- spec/lib/pagoid/kaminari_spec.rb
+- spec/lib/pagoid/pager_spec.rb
+- spec/lib/pagoid/will_paginate_spec.rb
+- spec/spec_helper.rb
+- spec/support/adapter_shared_example.rb
+- spec/support/person.rb