wor-paginate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d84187f4c6aefe0057da92521b232708da407df2
+  data.tar.gz: af3d77d7ed94db88542c07ad90649207dacbe804
+SHA512:
+  metadata.gz: 9b9a8636267edd5501e0f9f685c08a3d9ccf1342facdb0b6cc9d6beb7da7e0e0daf75acd248f32736ad841eabc754a4f5d7259d029ca20f7a0f3be7cc2f08d0b
+  data.tar.gz: 264eedc255fbaab4cbc28e4d9911eb3dd2713469ce82bdcdd7f1ca7a4fdd6d4157e327ae95eed69283ff2f7ba57171d2829e0628612e93872bf3831a8b604370

data/.gitignore

@@ -0,0 +1,331 @@
+spec/dummy/db/*.sqlite3
+spec/dummy/db/*.sqlite3-journal
+spec/dummy/log/*.log
+spec/dummy/tmp/
+
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+
+# Created by https://www.gitignore.io/api/ruby,rubymine,rails,emacs,vim,sublimetext,osx,macos,linux,windows
+
+### Emacs ###
+# -*- mode: gitignore; -*-
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+
+# Org-mode
+.org-id-locations
+*_archive
+
+# flymake-mode
+*_flymake.*
+
+# eshell files
+/eshell/history
+/eshell/lastdir
+
+# elpa packages
+/elpa/
+
+# reftex files
+*.rel
+
+# AUCTeX auto folder
+/auto/
+
+# cask packages
+.cask/
+dist/
+
+# Flycheck
+flycheck_*.el
+
+# server auth directory
+/server/
+
+# projectiles files
+.projectile
+
+# directory configuration
+.dir-locals.el
+
+### Linux ###
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### macOS ###
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### OSX ###
+
+# Icon must end with two \r
+
+
+# Thumbnails
+
+# Files that might appear in the root of a volume
+
+# Directories potentially created on remote AFP share
+
+### Rails ###
+*.rbc
+capybara-*.html
+.rspec
+/log
+/tmp
+/db/*.sqlite3
+/db/*.sqlite3-journal
+/public/system
+/coverage/
+/spec/tmp
+**.orig
+rerun.txt
+pickle-email-*.html
+
+# TODO Comment out this rule if you are OK with secrets being uploaded to the repo
+config/initializers/secret_token.rb
+
+# Only include if you have production secrets in this file, which is no longer a Rails default
+# config/secrets.yml
+
+# dotenv
+# TODO Comment out this rule if environment variables can be committed
+.env
+
+## Environment normalization:
+/.bundle
+/vendor/bundle
+
+# these should all be checked in to normalize the environment:
+# Gemfile.lock, .ruby-version, .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# if using bower-rails ignore default bower_components path bower.json files
+/vendor/assets/bower_components
+*.bowerrc
+bower.json
+
+# Ignore pow environment settings
+.powenv
+
+# Ignore Byebug command history file.
+.byebug_history
+
+### Ruby ###
+*.gem
+/.config
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+
+### RubyMine ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff:
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+
+# Sensitive or high-churn files:
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.xml
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+
+# Gradle:
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Mongo Explorer plugin:
+.idea/**/mongoSettings.xml
+
+## File-based project format:
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+### RubyMine Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+### SublimeText ###
+# cache files for sublime text
+*.tmlanguage.cache
+*.tmPreferences.cache
+*.stTheme.cache
+
+# workspace files are user-specific
+*.sublime-workspace
+
+# project files should be checked into the repository, unless a significant
+# proportion of contributors will probably not be using SublimeText
+# *.sublime-project
+
+# sftp configuration file
+sftp-config.json
+
+# Package control specific files
+Package Control.last-run
+Package Control.ca-list
+Package Control.ca-bundle
+Package Control.system-ca-bundle
+Package Control.cache/
+Package Control.ca-certs/
+Package Control.merged-ca-bundle
+Package Control.user-ca-bundle
+oscrypto-ca-bundle.crt
+bh_unicode_properties.cache
+
+# Sublime-github package stores a github token in this file
+# https://packagecontrol.io/packages/sublime-github
+GitHub.sublime-settings
+
+### Vim ###
+# swap
+[._]*.s[a-v][a-z]
+[._]*.sw[a-p]
+[._]s[a-v][a-z]
+[._]sw[a-p]
+# session
+Session.vim
+# temporary
+.netrwhist
+# auto-generated tag files
+tags
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+ehthumbs.db
+ehthumbs_vista.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.gitignore.io/api/ruby,rubymine,rails,emacs,vim,sublimetext,osx,macos,linux,windows

data/.rubocop.yml

@@ -0,0 +1,52 @@
+AllCops:
+  Exclude:
+    - wor-paginate.gemspec
+    - spec/spy.rb
+    - spec/dummy/db/**/*
+    - spec/dummy/config/**/*
+    - spec/spec_helper.rb
+
+Documentation:
+  Enabled: false
+
+LineLength:
+  Max: 99
+
+FrozenStringLiteralComment:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: true
+  Exclude:
+    - spec/**/*
+
+# rubocop-rspec custom configurations
+
+require: rubocop-rspec
+
+Style/VariableNumber:
+  EnforcedStyle: snake_case
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/AnyInstance:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Max: 5
+
+Lint/AmbiguousBlockAssociation:
+  Enabled: false
+
+RSpec/LetSetup:
+  Enabled: false
+
+RSpec/FilePath:
+  Exclude:
+    - spec/dummy_controller_without_gems_spec.rb
+    - spec/matchers_spec.rb
+    - spec/dummy_controller_spec.rb

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - 2.2.2
+  - 2.3.3
+  - 2.4.0
+
+install:
+  - gem install bundler
+  - bundle install --retry=3
+  - bundle exec rake db:migrate RAILS_ENV=test -f spec/dummy/Rakefile
+
+script:
+  - bundle exec rubocop --format simple
+  - bundle exec rspec
+  - bundle exec codeclimate-test-reporter

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+
+## Change log

data/Gemfile

@@ -0,0 +1,35 @@
+source 'https://rubygems.org'
+
+# Declare your gem's dependencies in wor-paginate.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use a debugger
+# gem 'byebug', group: [:development, :test]
+
+group :development, :test do
+  gem 'active_model_serializers', '~> 0.10.0'
+  gem 'bundler', '~> 1.13'
+  gem 'byebug', '~> 9.0'
+  gem 'codeclimate-test-reporter', '~> 1.0.0'
+  gem 'database_cleaner', '~> 1.5.0'
+  gem 'factory_girl_rails', '~> 4.7.0'
+  gem 'faker', '~> 1.7.0'
+  gem 'generator_spec', '~> 0.9.0'
+  gem 'kaminari', '~> 0.17.0'
+  gem 'rake', '~> 10.0'
+  gem 'rspec', '~> 3.0'
+  gem 'rspec-rails', '~> 3.6.0'
+  gem 'rubocop', '~> 0.49.1'
+  gem 'rubocop-rspec', '~> 1.15.0'
+  gem 'simplecov', '~> 0.13.0'
+  gem 'sqlite3', '~> 1.3.0'
+  gem 'webmock', '~> 3.0.0'
+  gem 'will_paginate', '~> 3.1.0'
+end

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Wolox
+
+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,181 @@
+# Wor::Paginate
+[![Build Status](https://travis-ci.org/Wolox/wor-requests.svg)](https://travis-ci.org/Wolox/wor-paginate)
+[![Gem Version](https://badge.fury.io/rb/wor-paginate.svg)](https://badge.fury.io/rb/wor-paginate)
+[![Dependency Status](https://gemnasium.com/badges/github.com/Wolox/wor-paginate.svg)](https://gemnasium.com/github.com/Wolox/wor-paginate)
+[![Code Climate](https://codeclimate.com/github/Wolox/wor-paginate/badges/gpa.svg)](https://codeclimate.com/github/Wolox/wor-paginate)
+[![Test Coverage](https://codeclimate.com/github/Wolox/wor-paginate/badges/coverage.svg)](https://codeclimate.com/github/Wolox/wor-paginate/coverage)
+
+Wor::Paginate is a gem for Rails that simplifies pagination, particularly for controller methods, while standardizing JSON output for APIs. It's meant to work both as a standalone pagination gem and as an extra layer over [Kaminari](https://github.com/kaminari/kaminari) and [will_paginate](https://github.com/mislav/will_paginate).
+
+## Installation
+Add the following line to your application's Gemfile:
+
+```ruby
+gem 'wor-paginate'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install wor-paginate
+```
+
+Then you can run `rails generate wor:paginate:install` to create the initializer for configuration details, including default formatter class, page and limit params and default page number.
+
+## Usage
+### Basic usage
+The basic use case is to paginate using default values. This is achieved by including the module in a controller and calling render_paginate in the method that needs pagination.
+```ruby
+  class DummyModelsController < ApplicationController
+    include Wor::Paginate
+
+    def index
+        render_paginated DummyModel
+    end
+  end
+```
+The first parameter to render_paginated can be multiple things:
+* ActiveRecord/ActiveRecord::Relation
+* Enumerables (for example, arrays and ranges)
+* Pre-paginated Kaminari or will_paginate relations (original pagination will be ignored)
+
+The response to the index will then be:
+```json
+{
+  "items": [
+    {
+      "id": 1,
+      "name": "1c",
+      "something": 27
+    },
+    {
+      "id": 2,
+      "name": "i",
+      "something": 68
+    },
+    ...
+    {
+      "id": 25,
+      "name": "2m",
+      "something": 32
+    }
+  ],
+  "count": 25,
+  "total_pages": 2,
+  "total_count": 28,
+  "current_page": 1,
+
+}
+```
+
+Page number is passed through the `page` option of the `render_paginated` method. If none is supplied, `params[:page]` will be used, (or the default parameter configured in the initializer).
+By default, if the page parameter is not present we will use 1 as the page (or the default `page` parameter configured in the initializer).
+The amount of items is passed through the `limit` option of the `render_paginated` method. If none is supplied, `params[:limit]` will be used (or the default parameter configured in the initializer). Default is 25.
+The default serializer and formatter will be used.
+
+### Customizing output
+#### Custom serializers
+A custom serializer for each object can be passed using the `each_serializer` option:
+```ruby
+render_paginated DummyModel, each_serializer: CustomDummyModelSerializer
+```
+where the serializer is just an [`ActiveModel::Serializer`](https://github.com/rails-api/active_model_serializers).
+
+#### Custom formatters
+A formatter is an object that defines the output of the render_paginated method. In case the application needs a different format for a request, it can be passed to the `render_paginated` method using the `formatter` option:
+```ruby
+render_paginated DummyModel, formatter: CustomFormatter
+```
+or it can also be set as a default in the initializer.
+
+A new formatter can be created inheriting from the default one. The `format` method should be redefined returning something that can be converted to json.
+
+```ruby
+class CustomFormatter < Wor::Paginate::Formatter
+  def format
+    { page: serialized_content, current: current_page }
+  end
+end
+```
+
+Available helper methods are:
+* `current_page`: integer with the current page
+* `count`: number of items in the page (post-pagination)
+* `total_count`: number of total items (pre-pagination)
+* `total_pages`: number of pages given the current limit (post-pagination)
+* `paginated_content`: its class depends on the original content passed to render_paginated, it's the paginated but not yet serialized content.
+* `serialized_content`: array with all the items after going through the serializer (either the default or a supplied one)
+
+### Working with Kaminari or will_paginate
+If either Kaminari or will_paginate are required in the project, Wor::Paginate will use them for pagination with no code or configuration change.
+
+### Test helpers
+You can use the `be_paginated` matcher to test your endpoints. It also accepts the `with` chain method to receive a formatter.
+
+You only need to add this in your spec_helper.rb (or rails_helper.rb)
+```
+# spec/spec_helper.rb
+require 'wor/paginate/rspec'
+```
+And in your spec do
+```
+# spec/controllers/your_controller.rb
+describe YourController do
+  describe '#index' do
+    it 'checks that the response keys matches with the default formatter' do
+      get :index
+      expect(response_body(response)).to be_paginated
+    end
+  end
+
+  describe '#index_with_custom_formatter' do
+    it 'checks that the response keys matches with the custom formatter' do
+      get :index_custom_formatter
+      expect(response_body(response)).to be_paginated.with(CustomFormatter)
+    end
+  end
+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. Run rubocop lint (`bundle exec rubocop -R --format simple`)
+5. Run rspec tests (`bundle exec rspec`)
+6. Push your branch (`git push origin my-new-feature`)
+7. Create a new Pull Request
+
+## About ##
+
+This project is maintained by [Hugo Farji](https://github.com/hdf1986), [Ignacio Coluccio](https://github.com/icoluccio), and [Alan Halatian](https://github.com/alanhala). It was written by [Wolox](http://www.wolox.com.ar).
+![Wolox](https://raw.githubusercontent.com/Wolox/press-kit/master/logos/logo_banner.png)
+
+## License
+
+**wor-paginate** is available under the MIT [license](https://raw.githubusercontent.com/Wolox/wor-paginate/master/LICENSE.md).
+
+    Copyright (c) 2017 Wolox
+
+    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/Rakefile

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

data/lib/generators/templates/wor_paginate.rb

@@ -0,0 +1,13 @@
+Wor::Paginate.configure do |config|
+  config.default_per_page = 25
+  # config.default_page = 1
+
+  config.page_param = :page
+  config.per_page_param = :per
+
+  # In case you want to use other format for your response, you can override our formatter here
+  # You can extend from Wor::Paginate::Formatter and override the 'format' method
+  # For more info about available methods for formatters see:
+  # https://github.com/Wolox/wor-paginate/blob/master/lib/wor/paginate/formatter.rb
+  # config.formatter = Wor::Paginate::Formatter
+end

data/lib/generators/wor/paginate/install_generator.rb

@@ -0,0 +1,14 @@
+module Wor
+  module Paginate
+    module Generators
+      class InstallGenerator < Rails::Generators::Base
+        source_root File.expand_path('../../../templates', __FILE__)
+        desc 'Creates Wor-Paginate initializer for your application'
+
+        def copy_initializer
+          template 'wor_paginate.rb', 'config/initializers/wor_paginate.rb'
+        end
+      end
+    end
+  end
+end

data/lib/wor/paginate.rb

@@ -0,0 +1,21 @@
+require_relative 'paginate/adapters/base'
+require_relative 'paginate/adapters/active_record'
+require_relative 'paginate/adapters/enumerable'
+require_relative 'paginate/adapters/kaminari'
+require_relative 'paginate/adapters/will_paginate'
+require_relative 'paginate/adapters/kaminari_already_paginated'
+require_relative 'paginate/adapters/will_paginate_already_paginated'
+require_relative 'paginate/exceptions/no_pagination_adapter'
+require_relative 'paginate/exceptions/invalid_page_number'
+require_relative 'paginate/exceptions/invalid_limit_number'
+require_relative 'paginate/formatter'
+require_relative 'paginate/config'
+require_relative 'paginate/paginate'
+
+module Wor
+  module Paginate
+    def self.configure
+      yield Config
+    end
+  end
+end

data/lib/wor/paginate/adapters/active_record.rb

@@ -0,0 +1,37 @@
+# Used when render_paginated is called with an ActiveRecord directly, without a
+# pagination gem like kaminari or will_paginate
+### render_paginated DummyModel
+module Wor
+  module Paginate
+    module Adapters
+      class ActiveRecord < Base
+        attr_reader :page
+
+        def required_methods
+          %i[offset limit table_name]
+        end
+
+        def paginated_content
+          @paginated_content ||= @content.offset(offset).limit(@limit)
+        end
+
+        delegate :count, to: :paginated_content
+
+        def total_count
+          @content.count
+        end
+
+        def total_pages
+          (total_count.to_f / @limit.to_f).ceil
+        end
+
+        private
+
+        def offset
+          return 0 if @page.zero?
+          (@page - 1) * @limit
+        end
+      end
+    end
+  end
+end

data/lib/wor/paginate/adapters/base.rb

@@ -0,0 +1,32 @@
+module Wor
+  module Paginate
+    module Adapters
+      class Base
+        attr_reader :page
+
+        def initialize(content, page, limit)
+          @content = content
+          @page = page.to_i
+          @limit = limit.to_i
+          raise Wor::Paginate::Exceptions::InvalidPageNumber if @page <= 0
+          raise Wor::Paginate::Exceptions::InvalidLimitNumber if @limit <= 0
+        end
+
+        def adapt?
+          required_methods.all? { |method| @content.respond_to? method }
+        end
+
+        %i[required_methods paginated_content count total_count next_page].each do |method|
+          define_method(method) { raise NotImplementedError }
+        end
+
+        delegate :total_pages, to: :paginated_content
+
+        def next_page
+          return nil if page >= total_pages
+          page + 1
+        end
+      end
+    end
+  end
+end

data/lib/wor/paginate/adapters/enumerable.rb

@@ -0,0 +1,31 @@
+# Used when render_paginated is called with an Enumerable, something like
+### render_paginated [1,2,3,4]
+module Wor
+  module Paginate
+    module Adapters
+      class Enumerable < Base
+        attr_reader :page
+
+        def required_methods
+          %i[to_a]
+        end
+
+        def paginated_content
+          return @paginated_content if @paginated_content
+          content_array = @content.to_a
+          @paginated_content = content_array.slice((page - 1) * @limit, @limit)
+        end
+
+        delegate :count, to: :paginated_content
+
+        def total_count
+          @content.count
+        end
+
+        def total_pages
+          (total_count / @limit.to_f).ceil
+        end
+      end
+    end
+  end
+end

data/lib/wor/paginate/adapters/kaminari.rb

@@ -0,0 +1,20 @@
+# Used when render_paginated is called with an ActiveModel directly, with kaminari
+# already required. Something like
+### render_paginated DummyModel
+module Wor
+  module Paginate
+    module Adapters
+      class Kaminari < Base
+        def required_methods
+          %i[page]
+        end
+
+        def paginated_content
+          @paginated_content ||= @content.page(@page).per(@limit)
+        end
+
+        delegate :count, :total_count, :total_pages, :next_page, to: :paginated_content
+      end
+    end
+  end
+end

data/lib/wor/paginate/adapters/kaminari_already_paginated.rb

@@ -0,0 +1,32 @@
+# Used when render_paginated is called with an already paginated ActiveModel with kaminari
+### render_paginated DummyModel.page
+module Wor
+  module Paginate
+    module Adapters
+      class KaminariAlreadyPaginated < Base
+        def required_methods
+          # Methods Kaminari adds to ActiveRecord relations:
+          ### [:padding, :per, :total_pages, :num_pages, :current_page, :first_page?,
+          ### :prev_page, :last_page?, :next_page, :out_of_range?, :total_count, :entry_name]
+          %i[padding total_count num_pages current_page prev_page]
+        end
+
+        def paginated_content
+          @paginated_content ||= @content.page(@page).per(@limit)
+        end
+
+        def count
+          @content.count
+        end
+
+        def total_count
+          @content.total_count
+        end
+
+        def total_pages
+          @content.total_pages
+        end
+      end
+    end
+  end
+end

data/lib/wor/paginate/adapters/will_paginate.rb

@@ -0,0 +1,30 @@
+# Used when render_paginated is called with an ActiveModel directly, with will_paginate
+# already required. Something like
+### render_paginated DummyModel
+module Wor
+  module Paginate
+    module Adapters
+      class WillPaginate < Base
+        attr_reader :page
+
+        def required_methods
+          %i[paginate]
+        end
+
+        def paginated_content
+          @paginated_content ||= @content.paginate(page: @page, per_page: @limit)
+        end
+
+        def count
+          paginated_content.to_a.size
+        end
+
+        def total_count
+          paginated_content.count
+        end
+
+        delegate :total_pages, :next_page, to: :paginated_content
+      end
+    end
+  end
+end

data/lib/wor/paginate/adapters/will_paginate_already_paginated.rb

@@ -0,0 +1,32 @@
+# Used when render_paginated is called with an already paginated ActiveModel with will_paginate
+### render_paginated DummyModel.paginate(page: 1)
+
+module Wor
+  module Paginate
+    module Adapters
+      class WillPaginateAlreadyPaginated < Base
+        attr_reader :page
+
+        def required_methods
+          # Methods will_paginate adds to ActiveRecord relations:
+          ### [:current_page, :total_entries, :total_entries=, :find_last, :current_page=,
+          ### :scoped, :total_pages, :next_page, :previous_page, :out_of_bounds?]
+          %i[previous_page out_of_bounds? total_entries= total_pages current_page=]
+        end
+
+        def paginated_content
+          @paginated_content ||= @content.limit(nil).offset(0)
+                                         .paginate(page: @page, per_page: @limit)
+        end
+
+        def count
+          paginated_content.to_a.size
+        end
+
+        def total_count
+          paginated_content.total_entries
+        end
+      end
+    end
+  end
+end

data/lib/wor/paginate/config.rb

@@ -0,0 +1,31 @@
+module Wor
+  module Paginate
+    module Config
+      DEFAULTS_CONFIGS = {
+        default_per_page: 25,
+        default_page: 1,
+        page_param: :page,
+        per_page_param: :per_page,
+        formatter: Wor::Paginate::Formatter,
+        max_limit: 50
+      }.freeze
+
+      module_function
+
+      DEFAULTS_CONFIGS.each do |key, value|
+        define_method key do
+          instance_variable_get("@#{key}") || instance_variable_set("@#{key}", value)
+        end
+
+        define_method "#{key}=" do |v|
+          instance_variable_set("@#{key}", v)
+        end
+      end
+
+      # This is mostly useful for the tests
+      def reset!
+        DEFAULTS_CONFIGS.each { |k, v| send("#{k}=", v) }
+      end
+    end
+  end
+end

data/lib/wor/paginate/exceptions/invalid_limit_number.rb

@@ -0,0 +1,8 @@
+module Wor
+  module Paginate
+    module Exceptions
+      class InvalidLimitNumber < StandardError
+      end
+    end
+  end
+end

data/lib/wor/paginate/exceptions/invalid_page_number.rb

@@ -0,0 +1,8 @@
+module Wor
+  module Paginate
+    module Exceptions
+      class InvalidPageNumber < StandardError
+      end
+    end
+  end
+end

data/lib/wor/paginate/exceptions/no_pagination_adapter.rb

@@ -0,0 +1,8 @@
+module Wor
+  module Paginate
+    module Exceptions
+      class NoPaginationAdapter < StandardError
+      end
+    end
+  end
+end

data/lib/wor/paginate/formatter.rb

@@ -0,0 +1,44 @@
+module Wor
+  module Paginate
+    class Formatter
+      attr_accessor :adapter, :content, :formatter, :options
+
+      def initialize(adapter, options = {})
+        @adapter = adapter
+        @options = options
+      end
+
+      def format
+        {
+          page: serialized_content,
+          count: count,
+          total_pages: total_pages,
+          total_count: total_count,
+          current_page: current_page,
+          next_page: next_page
+        }
+      end
+
+      protected
+
+      delegate :count, :total_count, :total_pages, :next_page, to: :adapter
+
+      def current_page
+        adapter.page.to_i
+      end
+
+      def paginated_content
+        @content ||= adapter.paginated_content
+      end
+
+      def serialized_content
+        return paginated_content.as_json if serializer.blank?
+        paginated_content.map { |item| serializer.new(item) }
+      end
+
+      def serializer
+        options[:each_serializer]
+      end
+    end
+  end
+end

data/lib/wor/paginate/paginate.rb

@@ -0,0 +1,52 @@
+module Wor
+  module Paginate
+    # The order of this array is important!
+    # In a future release we'll provide an interface to manipulate it
+    ADAPTERS = [
+      Adapters::KaminariAlreadyPaginated,
+      Adapters::WillPaginateAlreadyPaginated,
+      Adapters::WillPaginate,
+      Adapters::Kaminari,
+      Adapters::ActiveRecord,
+      Adapters::Enumerable
+    ].freeze
+
+    def render_paginated(content, options = {})
+      render json: paginate(content, options)
+    end
+
+    def paginate(content, options = {})
+      adapter = find_adapter_for_content(content, options)
+      raise Exceptions::NoPaginationAdapter if adapter.blank?
+      formatter_class(options).new(adapter, options).format
+    end
+
+    def formatter_class(options)
+      options[:formatter].presence || Formatter
+    end
+
+    def find_adapter_for_content(content, options)
+      ADAPTERS.map { |adapter| adapter.new(content, page(options), limit(options)) }
+              .find(&:adapt?)
+    end
+
+    def page(options)
+      options[:page] || params[Config.page_param] || Config.default_page
+    end
+
+    def option_limit(options)
+      options[:limit].to_i unless options[:limit].nil?
+    end
+
+    def param_limit
+      params[Config.per_page_param].to_i unless params[Config.per_page_param].nil?
+    end
+
+    def limit(options)
+      [
+        Config.max_limit,
+        option_limit(options) || param_limit || Config.default_per_page
+      ].min
+    end
+  end
+end

data/lib/wor/paginate/rspec.rb

@@ -0,0 +1,47 @@
+class MockedAdapter < Wor::Paginate::Adapters::Base
+  def initialize; end
+
+  def count
+    3
+  end
+
+  def total_count
+    5
+  end
+
+  def total_pages
+    10
+  end
+
+  def next_page
+    2
+  end
+
+  def page
+    1
+  end
+
+  def paginated_content
+    []
+  end
+end
+
+RSpec::Matchers.define :be_paginated do
+  match do |actual_response|
+    formatter = @custom_formatter || Wor::Paginate::Formatter
+    @formatted_keys = formatter.new(MockedAdapter.new).format.as_json.keys
+    actual_response.keys == @formatted_keys
+  end
+
+  chain :with do |custom_formatter|
+    @custom_formatter = custom_formatter
+  end
+
+  failure_message do |actual_response|
+    "expected that #{actual_response} to be paginated with keys #{@formatted_keys}"
+  end
+
+  failure_message_when_negated do |actual_response|
+    "expected that #{actual_response} not to be paginated with keys #{@formatted_keys}"
+  end
+end

data/lib/wor/paginate/version.rb

@@ -0,0 +1,5 @@
+module Wor
+  module Paginate
+    VERSION = '0.1.0'.freeze
+  end
+end

data/wor-paginate.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "wor/paginate/version"
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name        = "wor-paginate"
+  s.version     = Wor::Paginate::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.date        = Date.today
+  s.authors     = ["hdf1986", "icoluccio", "alanhala"]
+  s.email       = ["hugo.farji@wolox.com.ar", "ignacio.coluccio@wolox.com.ar", "alan.halatian@wolox.com.ar"]
+  s.homepage    = "https://github.com/Wolox/wor-paginate"
+  s.summary     = "Simplified pagination for Rails API controllers"
+  s.description = "Wor::Paginate is a gem for Rails that simplifies pagination, particularly for controller methods, while standardizing JSON output for APIs. It's meant to work both as a standalone pagination gem and as an extra layer over Kaminari and will_paginate"
+  s.license     = "MIT"
+
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec)/}) }
+  s.require_paths = ['lib']
+
+
+  s.add_dependency 'railties', '>= 4.1.0', '<= 5.1'
+  s.add_dependency 'rails', '>= 4.0'
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: wor-paginate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- hdf1986
+- icoluccio
+- alanhala
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Wor::Paginate is a gem for Rails that simplifies pagination, particularly
+  for controller methods, while standardizing JSON output for APIs. It's meant to
+  work both as a standalone pagination gem and as an extra layer over Kaminari and
+  will_paginate
+email:
+- hugo.farji@wolox.com.ar
+- ignacio.coluccio@wolox.com.ar
+- alan.halatian@wolox.com.ar
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/generators/templates/wor_paginate.rb
+- lib/generators/wor/paginate/install_generator.rb
+- lib/wor/paginate.rb
+- lib/wor/paginate/adapters/active_record.rb
+- lib/wor/paginate/adapters/base.rb
+- lib/wor/paginate/adapters/enumerable.rb
+- lib/wor/paginate/adapters/kaminari.rb
+- lib/wor/paginate/adapters/kaminari_already_paginated.rb
+- lib/wor/paginate/adapters/will_paginate.rb
+- lib/wor/paginate/adapters/will_paginate_already_paginated.rb
+- lib/wor/paginate/config.rb
+- lib/wor/paginate/exceptions/invalid_limit_number.rb
+- lib/wor/paginate/exceptions/invalid_page_number.rb
+- lib/wor/paginate/exceptions/no_pagination_adapter.rb
+- lib/wor/paginate/formatter.rb
+- lib/wor/paginate/paginate.rb
+- lib/wor/paginate/rspec.rb
+- lib/wor/paginate/version.rb
+- wor-paginate.gemspec
+homepage: https://github.com/Wolox/wor-paginate
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Simplified pagination for Rails API controllers
+test_files: []