wor-paginate 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2465192c522659e0f6e779d73cda2dfaa3fa47aca0966ebc9fd4292587143cea
-  data.tar.gz: d71ab589396a9f76e25849e63bec31a1fe5aafcd1dd54c3b9ca79104957cbee7
+  metadata.gz: 4481aa957c0963f107c5f1bdd9b2c6859cf91930aa7737e1a184a5634ad2bddf
+  data.tar.gz: 3a66f12b6c3348f7e43aa98586218d812ba6df36f6917a926d8bd1abc19caf61
 SHA512:
-  metadata.gz: 8ed75b64b43ffe168a35a09a054532c384d51470e3942964b8a60ac191644b264e8d42a59e73ceea3485a0cc7680162a74dcd9d81b5581a110bb8510f965dfcc
-  data.tar.gz: 93143a274cdbd3bbaffe3898fa4038de9173b6d916eab033e5ae13c8fcaceb63baefc8c7a4d0a6c6ffbb4fc2f6513c2d68769a533fdc05416d3d5336c256dfd8
+  metadata.gz: 8924bd31085db92676e53a290e5d9ae109295f15af0a908b798dec323a99a5c9b97a1b367cdc17f219126167bf4d6f703cc44a419c5d06acee3d8fe81d96c2d8
+  data.tar.gz: 989d4fb9cef8a3e149178c1f1a777195f1b63b54ddf6e2be10e7612b11bb95a04ba6b3280680a90918e56473efba951439bfeb362eb681a98e4f7cdfe5a33254

data/.github/workflows/ci.yml

@@ -0,0 +1,52 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    name: "Ruby ${{ matrix.ruby }} / Rails ${{ matrix.rails }}"
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['3.2', '3.3', '3.4']
+        rails: ['6.1', '7.0', '7.1', '7.2', '8.0', '8.1']
+    steps:
+      - uses: actions/checkout@v7
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: false
+      - name: Generate appraisal gemfiles
+        run: |
+          bundle install
+          bundle exec appraisal generate
+      - name: Install dependencies for this Rails version
+        env:
+          BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/rails_${{ matrix.rails }}.gemfile
+        run: bundle install
+      - name: Prepare test database
+        env:
+          BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/rails_${{ matrix.rails }}.gemfile
+          RAILS_ENV: test
+        working-directory: spec/dummy
+        run: bundle exec rails db:schema:load
+      - name: Run tests
+        env:
+          BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/rails_${{ matrix.rails }}.gemfile
+        run: bundle exec rspec
+
+  lint:
+    name: RuboCop
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4'
+          bundler-cache: true
+      - name: Run RuboCop
+        run: bundle exec rubocop lib spec --format simple

data/.gitignore

@@ -1,5 +1,6 @@
 spec/dummy/db/*.sqlite3
 spec/dummy/db/*.sqlite3-journal
+/test.sqlite3
 spec/dummy/log/*.log
 spec/dummy/tmp/
 
@@ -330,3 +331,13 @@ $RECYCLE.BIN/
 *.lnk
 
 # End of https://www.gitignore.io/api/ruby,rubymine,rails,emacs,vim,sublimetext,osx,macos,linux,windows
+
+### Claude Code / superpowers ###
+CLAUDE.md
+.claude/
+docs/superpowers/
+.superpowers/
+
+### Appraisal ###
+/gemfiles/*.gemfile
+/gemfiles/*.gemfile.lock

data/.overcommit.yml

@@ -0,0 +1,16 @@
+PrePush:
+  ALL:
+    problem_on_unmodified_line: report
+    requires_files: false
+    quiet: false
+
+  RuboCop:
+    enabled: true
+    command: ['bundle', 'exec', 'rubocop']
+
+  CustomScript:
+    enabled: true
+    description: 'Run RSpec with 100% coverage gate'
+    command: ['bundle', 'exec', 'rspec']
+    env:
+      BUNDLE_GEMFILE: gemfiles/rails_8.1.gemfile

data/.rubocop.yml

@@ -1,19 +1,23 @@
+plugins:
+  - rubocop-rspec
+
 AllCops:
   Exclude:
     - wor-paginate.gemspec
-    - spec/spy.rb
     - spec/dummy/db/**/*
     - spec/dummy/config/**/*
-    - spec/spec_helper.rb
-  TargetRubyVersion: 2.3.8
+    - spec/dummy/bin/**/*
+  TargetRubyVersion: 3.2
+  NewCops: disable
+  SuggestExtensions: false
 
-Documentation:
+Style/Documentation:
   Enabled: false
 
-LineLength:
+Layout/LineLength:
   Max: 99
 
-FrozenStringLiteralComment:
+Style/FrozenStringLiteralComment:
   Enabled: false
 
 Metrics/BlockLength:
@@ -23,9 +27,7 @@ Metrics/BlockLength:
 
 # rubocop-rspec custom configurations
 
-require: rubocop-rspec
-
-Style/VariableNumber:
+Naming/VariableNumber:
   EnforcedStyle: snake_case
 
 RSpec/ExampleLength:
@@ -46,8 +48,13 @@ Lint/AmbiguousBlockAssociation:
 RSpec/LetSetup:
   Enabled: false
 
-RSpec/FilePath:
+# matchers_spec.rb describes DummyModelsController to test the be_paginated
+# matcher against real responses, not to test the controller itself, so its
+# name doesn't follow the described-class convention on purpose.
+RSpec/SpecFilePathFormat:
+  Exclude:
+    - spec/matchers_spec.rb
+
+RSpec/SpecFilePathSuffix:
   Exclude:
-    - spec/dummy_controller_without_gems_spec.rb
     - spec/matchers_spec.rb
-    - spec/dummy_controller_spec.rb

data/Appraisals

@@ -0,0 +1,41 @@
+# sqlite3 is pinned per Rails version here, not in the Gemfile: activerecord
+# 6.1/7.0 hard-pin "~> 1.4" internally, 8.0/8.1 need ">= 2.1", and Bundler
+# won't allow the same gem pinned twice in one Gemfile.
+
+appraise 'rails-6.1' do
+  gem 'rails', '~> 6.1.0'
+
+  # activesupport 6.1.x requires mutex_m without declaring it; Ruby 3.4+ no
+  # longer bundles it by default.
+  gem 'mutex_m'
+
+  # Same issue for benchmark, removed by default in Ruby 4.0.
+  gem 'benchmark'
+
+  gem 'sqlite3', '~> 1.4'
+end
+
+appraise 'rails-7.0' do
+  gem 'rails', '~> 7.0.0'
+  gem 'sqlite3', '~> 1.4'
+end
+
+appraise 'rails-7.1' do
+  gem 'rails', '~> 7.1.0'
+  gem 'sqlite3', '~> 2.9'
+end
+
+appraise 'rails-7.2' do
+  gem 'rails', '~> 7.2.0'
+  gem 'sqlite3', '~> 2.9'
+end
+
+appraise 'rails-8.0' do
+  gem 'rails', '~> 8.0.0'
+  gem 'sqlite3', '~> 2.9'
+end
+
+appraise 'rails-8.1' do
+  gem 'rails', '~> 8.1.0'
+  gem 'sqlite3', '~> 2.9'
+end

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## Change log
 
+### V0.4.0
+* [#1](https://github.com/icoluccio/wor-paginate/pull/1) Add Rails 8.0/8.1 support, HTTP-level request specs, and rubocop cleanup - [@icoluccio](https://github.com/icoluccio).
+
+### V0.3.0
+* [#94](https://github.com/Wolox/wor-paginate/pull/94) Add Panko formatter - [@blacksam07](https://github.com/blacksam07).
+* [#96](https://github.com/Wolox/wor-paginate/pull/96) Dynamic Adapters - [@juanpablo-rojas](https://github.com/juanpablo-rojas).
+
 ### V0.2.0
 * [#95](https://github.com/Wolox/wor-paginate/pull/95) Added total_count option to overwrite the count in render_paginated  - [@juanpablo-rojas](https://github.com/juanpablo-rojas).
 * [#93](https://github.com/Wolox/wor-paginate/pull/93) Infinite scroll - [@mnmallea](https://github.com/mnmallea).

data/Gemfile

@@ -14,22 +14,25 @@ gemspec
 # gem 'byebug', group: [:development, :test]
 
 group :development, :test do
-  gem 'active_model_serializers', '~> 0.10.0'
-  gem 'bundler', '>= 2.0.1'
-  gem 'byebug', '~> 9.0'
-  gem 'codeclimate-test-reporter', '~> 1.0.0'
-  gem 'database_cleaner', '~> 1.6.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.4'
-  gem 'webmock', '~> 3.0.0'
-  gem 'will_paginate', '~> 3.1.0'
+  gem 'active_model_serializers', '~> 0.10.16'
+  gem 'appraisal', '~> 2.5'
+  gem 'byebug', '~> 13.0'
+  gem 'database_cleaner-active_record', '~> 2.2', require: 'database_cleaner/active_record'
+  gem 'factory_bot_rails', '~> 6.5'
+  gem 'faker', '~> 3.8'
+  gem 'generator_spec', '~> 0.10'
+  gem 'kaminari', '~> 1.2'
+  gem 'overcommit', '~> 0.71'
+  gem 'panko_serializer', '~> 0.8.5'
+  gem 'puma', '~> 6.0'
+  gem 'rake', '~> 13.0'
+  gem 'rspec', '~> 3.13'
+  gem 'rspec-rails', '>= 6.0', '< 9'
+  gem 'rubocop', '~> 1.88'
+  gem 'rubocop-rspec', '~> 3.10'
+  gem 'simplecov', '~> 0.22'
+  # sqlite3 is pinned per Rails version in Appraisals instead, since the
+  # required range differs across supported versions.
+  gem 'webmock', '~> 3.26'
+  gem 'will_paginate', '~> 4.0'
 end

data/LICENSE.md

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) 2017 Wolox
+Copyright (c) 2026 Ignacio Coluccio
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,9 +1,8 @@
 Wor::Paginate
 =============
 
-[![Build Status](https://travis-ci.org/Wolox/wor-paginate.svg?branch=master)](https://travis-ci.org/Wolox/wor-paginate)
+[![CI](https://github.com/icoluccio/wor-paginate/actions/workflows/ci.yml/badge.svg)](https://github.com/icoluccio/wor-paginate/actions/workflows/ci.yml)
 [![Gem Version](https://badge.fury.io/rb/wor-paginate.svg)](https://badge.fury.io/rb/wor-paginate)
-[![Code Climate](https://codeclimate.com/github/Wolox/wor-paginate/badges/gpa.svg)](https://codeclimate.com/github/Wolox/wor-paginate)
 
 # Table of contents
   - [Description](#description)
@@ -14,6 +13,7 @@ Wor::Paginate
       - [Custom serializers](#custom-serializers)
       - [Custom options](#custom-options)
       - [Custom formatters](#custom-formatters)
+      - [Custom adapters](#custom-adapters)
     - [Working with Kaminari or will_paginate](#working-with-kaminari-or-will_paginate)
     - [Test helpers](#test-helpers)
   - [Contributing](#contributing)
@@ -48,7 +48,7 @@ Then you can run `rails generate wor:paginate:install` to create the initializer
 
 ## 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.
+The basic use case is to paginate using default values. This is achieved by including the module in a controller and calling render_paginated in the method that needs pagination.
 ```ruby
   class DummyModelsController < ApplicationController
     include Wor::Paginate
@@ -91,11 +91,11 @@ The response to the index will then be:
   "previous_page": null,
   "next_page": 2,
   "previous_page_url": null,
-  "next_page_url": "http://api.example.com/users?page=2
+  "next_page_url": "http://api.example.com/users?page=2"
 }
 ```
 
-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).
+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.
@@ -110,7 +110,7 @@ where the serializer is just an [`ActiveModel::Serializer`](https://github.com/r
 
 #### Custom options
 ##### max_limit
-The max amount of items is passed through the `max_limit` option, You can set the value in the initializer or in the `render_paginated` method, (If none is supplied, take the default value configured in the initializer). Default is 50.
+The max amount of items is passed through the `max_limit` option. You can set the value in the initializer or in the `render_paginated` method (If none is supplied, take the default value configured in the initializer). Default is 50.
 
 ```ruby
   render_paginated DummyModel, max_limit: 100
@@ -134,7 +134,7 @@ end
 ```
 
 ##### total_count
-You can overwrite the `total_count` pagination param by passing it as a single option to the method. This could be used if the whole collection to be paginated is complex and has the risk to broke when counting all the records.
+You can overwrite the `total_count` pagination param by passing it as a single option to the method. This could be used if the whole collection to be paginated is complex and has the risk to break when counting all the records.
 
 ```ruby
   render_paginated DummyModel, total_count: 50
@@ -143,7 +143,7 @@ You can overwrite the `total_count` pagination param by passing it as a single o
 ##### preserve_records
 > WARNING: This option only works with an ActiveRecord collection.
 
-Preserve records option can be added to `render_paginated` to mantain current records. This allow to navigate pages like an infinite scroll without adding new records when switching pages.
+Preserve records option can be added to `render_paginated` to maintain current records. This allows to navigate pages like an infinite scroll without adding new records when switching pages.
 
 - Timestamp mode (default)
 ```ruby
@@ -170,17 +170,17 @@ end
 ```
 
 
-#### Custom formatters
+### 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.
+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
+class CustomFormatter < Wor::Paginate::Formatters::Base
   def format
     { page: serialized_content, current: current_page }
   end
@@ -195,8 +195,76 @@ Available helper methods are:
 * `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)
 
+
+### Custom adapters
+An adapter is an object that defines how to show the rendered content, and how to calculate several methods of the pagination, such as 'total_count', 'total_pages', 'paginated_content' among others. In case the application needs a different adapter or a custom one, it can be passed to the `render_paginated` method using the `adapter` option:
+```ruby
+render_paginated DummyModel, adapter: CustomAdapter
+```
+or it can also be set as a default in the initializer.
+
+A new adapter can be created inheriting from the default Base Adapter. Some methods must be redefined in order to make the adapter "adaptable" to the content that will be rendered.
+Below is an example of a simple possible CustomAdapter that extends from the base Adapter.
+
+```ruby
+class CustomAdapter < Wor::Paginate::Adapters::Base
+  def required_methods
+    %i[count]
+  end
+
+  def paginated_content
+    @paginated_content ||= @content.first(5)
+  end
+
+  def total_pages
+    (total_count / @limit.to_f).ceil
+  end
+
+  def total_count
+    @content.count
+  end
+
+  delegate :count, to: :paginated_content
+end
+```
+Here's a brief explanation on every overwritten method in this CustomAdapter example:
+
+##### `#required_methods`
+These will be the methods (as symbols) that the content to be rendered has to support. The next expression will be evaluated for every method added here: `@content.respond_to? method`. All required_methods must answer `true` to the previous expression, in order to make the adapter "adaptable" for the content. For example, if we rendered an ActiveRecord::Relation, this CustomAdapter would be adaptable because an ActiveRecord::Relation responds to the `#count` method. At least one symbol has to be returned in this method, otherwise the adapter won't be able to render content. 
+
+##### `#paginated_content`
+This is how the content will be shown. As the content comes in the inherited instance variable `@content`, we can transform the content however we want. In the CustomAdapter example, the first 5 records will always be shown.
+
+##### `#total_pages`
+This could be defined as the number of pages, given the limit requested. As the other values, this can be a custom number of pages, depending on your needs. For this example, this number is just an integer calculation of the total pages, depending on the limit. Also, like `@content`, we are inheriting the `@limit` variable, which allows us to operate with it however we want.
+
+##### `#total_count`
+This will be the number that will tell us 'how many records is returning the request'. Again, we can customize it however we want. For this particular example this will be just the count of `@content`.
+
+##### `#count` method as delegate
+At the end of the CustomAdapter we are delegating the `#count` method to the `paginated_content`. This is because the Base Adapter delegates that method to the inherited adapter, so our custom adapter has to know "how to calculate" that method, that's why we are defining a `#count` method in the delegation (It is always mandatory to define the `#count` method in a custom adapter, whether it is a method definition or a delegate).
+
+If the content is an ActiveRecord::Relation, for example, this adapter would work, because `paginated_content` would become an ActiveRecord::Relation, which actually knows "how to calculate" the count method. This works as a delegate, because ActiveRecord::Relation has an internal `#count` definition, but we would have to provide the needed method definition if it is a custom method, or if we want a custom behaviour of a known method.
+
+##### Other available methods to overwrite
+`Wor::Paginate::Adapters::Base` also has implementations for `#next_page` and `#previous_page` methods (which calculate the number of the next and previous pages, respectively). If you want, you can also overwrite those methods, to calculate custom 'next' and 'previous' page numbers.
+
+To understand better the implementation of the Base Adapter and how you could overwrite methods in order to make a functional Custom Adapter, take a look at its definition in: [Base adapter Class](https://github.com/icoluccio/wor-paginate/blob/main/lib/wor/paginate/adapters/base.rb).
+Keep in mind that an instance of your Custom Adapter must answer `true` to the `#adapt?` method inherited from the Base Adapter, in order to make it "adaptable" to the content.
+
+#### Adapters Operations
+There are also helper methods available to dynamically operate the gem's adapters, so you can configure them, whether in the initializer or in an internal part of your application. Once you include the gem, you'll be provided with the following methods, inside the Config module:
+* `Wor::Paginate::Config.add_adapter(adapter)`: Add a specific adapter to the array of the gem's adapters. The 'adapter' variable must be a Class reference to an Adapter Class (that class has to have a similar structure as the CustomAdapter example above).
+* `Wor::Paginate::Config.remove_adapter(adapter)`: Remove a specific adapter from the array of the gem's adapters.
+* `Wor::Paginate::Config.clear_adapters`: This method empties the array of the gem's adapters.
+* `Wor::Paginate::Config.adapters`: Returns all the current internal adapters inside the gem.
+* `Wor::Paginate::Config.reset_adapters!`: This helper resets the gem's adapters to its default array of adapters. You can see how the array of default adapters looks like at the beginning of the `Wor::Paginate::Config` module: [Config module](https://github.com/icoluccio/wor-paginate/blob/main/lib/wor/paginate/config.rb).
+
+When the gem paginates, it tries to adapt the content to the first adapter that is "adaptable" for the content (unless a custom adapter has been passed to render_paginated or a default_adapter has been defined in the initializer). So beware of which adapters (and in which order) you are leaving in the `Wor::Paginate::Config.adapters` array, because depending on those, the gem will try to adapt the content.
+
+
 ### 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.
+If either Kaminari or will_paginate is 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.
@@ -232,38 +300,61 @@ describe YourController do
 end
 ```
 
+### Working with panko-serializer
+
+The default formatter is [Active Model Serializer](https://github.com/rails-api/active_model_serializers).
+If you want to change it, you should replace the formatter with another one. In this section, we are going to work with `PankoFormatter`
+
+#### example 
+```ruby
+Wor::Paginate.configure do |config|
+  config.formatter = Wor::Paginate::Formatters::PankoFormatter
+end
+```
+and next, pass the specific serializer that you can use in the specific endpoint
+
+```ruby
+  def index
+    render_paginated DummyModel, each_serializer: DummyModelPankoSerializer
+  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 to `master` branch
+2. Run `bundle install && bundle exec appraisal generate` once, to install dependencies and generate the per-Rails-version gemfiles (`gemfiles/rails_*.gemfile`) used for testing
+3. Run `bundle exec overcommit --install` once, to enable the pre-push hook (runs RuboCop and the full spec suite with its 100%-coverage gate automatically on every `git push`)
+4. Create your feature branch (`git checkout -b my-new-feature`)
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Run RuboCop lint (`bundle exec rubocop lib spec --format simple`)
+7. Run rspec tests (`BUNDLE_GEMFILE=gemfiles/rails_8.1.gemfile bundle exec rspec`)
+8. Push your branch (`git push origin my-new-feature`) — the pre-push hook re-verifies both automatically
+9. Create a new Pull Request to `main` branch
 
 ## Releases
-📢 [See what's changed in a recent version](https://github.com/Wolox/wor-paginate/releases)
+📢 [See what's changed in a recent version](https://github.com/icoluccio/wor-paginate/releases)
 
 ## About ##
 
-The current maintainers of this gem are :
-* [Martín Mallea](https://github.com/mnmallea)
+The current maintainer of this gem is:
+* [Ignacio Coluccio](https://github.com/icoluccio)
 
 This project was developed by:
-* [Hugo Farji](https://github.com/hdf1986)
 * [Ignacio Coluccio](https://github.com/icoluccio)
+* [Martín Mallea](https://github.com/mnmallea)
+* [Samir Tapiero](https://github.com/blacksam07)
+* [Hugo Farji](https://github.com/hdf1986)
 * [Alan Halatian](https://github.com/alanhala)
 
-At [Wolox](http://www.wolox.com.ar)
+Originally at [Wolox](http://www.wolox.com.ar)
 
 [![Wolox](https://raw.githubusercontent.com/Wolox/press-kit/master/logos/logo_banner.png)](http://www.wolox.com.ar)
 
 ## License
 
-**wor-paginate** is available under the MIT [license](https://raw.githubusercontent.com/Wolox/wor-paginate/master/LICENSE.md).
+**wor-paginate** is available under the MIT [license](https://raw.githubusercontent.com/icoluccio/wor-paginate/main/LICENSE.md).
 
     Copyright (c) 2017 Wolox
+    Copyright (c) 2026 Ignacio Coluccio
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"), to deal

data/lib/generators/templates/wor_paginate.rb

@@ -6,10 +6,10 @@ Wor::Paginate.configure do |config|
   config.per_page_param = :limit
 
   # 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
+  # You can extend from Wor::Paginate::Formatters::Base 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
+  # https://github.com/Wolox/wor-paginate/blob/master/lib/wor/paginate/formatters/base.rb
+  # config.formatter = Wor::Paginate::Formatters::AmsFormatter
 
   # Configure a default adapter to use on pagination
   # config.default_adapter = nil
@@ -22,4 +22,19 @@ Wor::Paginate.configure do |config|
   # Wor::Paginate::Adapters::Kaminari
   # Wor::Paginate::Adapters::ActiveRecord
   # Wor::Paginate::Adapters::Enumerable
+
+  # Custom adapters
+
+  # config.adapters = [
+  # Adapters::KaminariAlreadyPaginated,
+  # Adapters::WillPaginateAlreadyPaginated,
+  # Adapters::WillPaginate,
+  # Adapters::Kaminari,
+  # Adapters::ActiveRecord,
+  # Adapters::Enumerable
+  # ]
+  # config.add_adapter(adapter)
+  # config.remove_adapter(adapter)
+  # config.clear_adapters
+  # config.reset_adapters!
 end

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

@@ -2,7 +2,7 @@ module Wor
   module Paginate
     module Generators
       class InstallGenerator < Rails::Generators::Base
-        source_root File.expand_path('../../../templates', __FILE__)
+        source_root File.expand_path('../../templates', __dir__)
         desc 'Creates Wor-Paginate initializer for your application'
 
         def copy_initializer

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

@@ -24,13 +24,14 @@ module Wor
         end
 
         def total_pages
-          (total_count.to_f / @limit.to_f).ceil
+          (total_count.to_f / @limit).ceil
         end
 
         private
 
         def offset
           return 0 if @page.zero?
+
           (@page - 1) * @limit
         end
       end

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

@@ -12,6 +12,7 @@ module Wor
 
         def paginated_content
           return @paginated_content if @paginated_content
+
           content_array = @content.to_a
           @paginated_content = content_array.slice((page - 1) * @limit, @limit) || []
         end

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

@@ -6,9 +6,11 @@ module Wor
       class KaminariAlreadyPaginated < Base
         def required_methods
           # Methods Kaminari adds to ActiveRecord relations:
-          ### [:padding, :per, :total_pages, :num_pages, :current_page, :first_page?,
+          ### [:padding, :per, :total_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]
+          # num_pages was removed upstream (kaminari-core 1.2.2 only defines
+          # total_pages); checking for it made adapt? always fail.
+          %i[padding total_count total_pages current_page prev_page]
         end
 
         def paginated_content

data/lib/wor/paginate/config.rb

@@ -6,11 +6,22 @@ module Wor
         default_page: 1,
         page_param: :page,
         per_page_param: :limit,
-        formatter: Wor::Paginate::Formatter,
+        formatter: Wor::Paginate::Formatters::Base,
         max_limit: 50,
         default_adapter: nil
       }.freeze
 
+      DEFAULT_ADAPTERS = {
+        kaminari_paginated: Adapters::KaminariAlreadyPaginated,
+        will_paginate_paginated: Adapters::WillPaginateAlreadyPaginated,
+        will_paginate: Adapters::WillPaginate,
+        kaminari: Adapters::Kaminari,
+        active_record: Adapters::ActiveRecord,
+        enumerable: Adapters::Enumerable
+      }.freeze
+
+      @adapters = DEFAULT_ADAPTERS.values
+
       module_function
 
       DEFAULTS_CONFIGS.each do |key, value|
@@ -23,10 +34,30 @@ module Wor
         end
       end
 
+      def add_adapter(adapter)
+        @adapters << adapter
+      end
+
+      def remove_adapter(adapter)
+        @adapters.delete(adapter)
+      end
+
+      def clear_adapters
+        @adapters.clear
+      end
+
+      def adapters
+        @adapters
+      end
+
       # This is mostly useful for the tests
       def reset!
         DEFAULTS_CONFIGS.each { |k, v| send("#{k}=", v) }
       end
+
+      def reset_adapters!
+        @adapters = DEFAULT_ADAPTERS.values
+      end
     end
   end
 end

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

@@ -0,0 +1,11 @@
+module Wor
+  module Paginate
+    module Exceptions
+      class DependencyError < StandardError
+        def initialize(msg = 'Serializer dependency error')
+          super(msg)
+        end
+      end
+    end
+  end
+end

data/lib/wor/paginate/formatters/ams_formatter.rb

@@ -0,0 +1,24 @@
+module Wor
+  module Paginate
+    module Formatters
+      class AmsFormatter < Base
+        def serialized_content
+          return serializable_resource.new(paginated_content).as_json unless serializer.present?
+
+          raise_dependency_error unless serializer.respond_to?('_attributes_data')
+          paginated_content.map { |item| serializer.new(item, options) }
+        end
+
+        private
+
+        def serializable_resource
+          ActiveModelSerializers::SerializableResource
+        end
+
+        def raise_dependency_error
+          raise Wor::Paginate::Exceptions::DependencyError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'wor/paginate/utils/uri_helper'
+
+module Wor
+  module Paginate
+    module Formatters
+      class Base
+        include Utils::UriHelper
+        attr_accessor :adapter, :content, :formatter, :options
+
+        def initialize(adapter, options = {})
+          @adapter = adapter
+          @options = options
+        end
+
+        def format # rubocop: disable Metrics/MethodLength
+          {
+            page: serialized_content,
+            count: count,
+            total_pages: total_pages,
+            total_count: options[:total_count] || total_count,
+            current_page: current_page,
+            previous_page: previous_page,
+            next_page: next_page,
+            next_page_url: page_url(next_page),
+            previous_page_url: page_url(previous_page)
+          }
+        end
+
+        protected
+
+        delegate :count, :total_count, :total_pages, :previous_page, :next_page, to: :adapter
+
+        def current_page
+          adapter.page.to_i
+        end
+
+        def paginated_content
+          # rubocop:disable Naming/MemoizedInstanceVariableName -- @content matches the public `content` attr_accessor above; renaming it would silently change what `content` returns.
+          @content ||= adapter.paginated_content
+          # rubocop:enable Naming/MemoizedInstanceVariableName
+        end
+
+        def serialized_content
+          paginated_content.as_json
+        end
+
+        def serializer
+          options[:each_serializer]
+        end
+
+        def page_url(page)
+          return nil unless page
+
+          replace_query_params(current_url, page: page)
+        end
+
+        def current_url
+          options[:_current_url]
+        end
+      end
+    end
+  end
+end

data/lib/wor/paginate/formatters/panko_formatter.rb

@@ -0,0 +1,21 @@
+module Wor
+  module Paginate
+    module Formatters
+      class PankoFormatter < Base
+        def serialized_content
+          raise Wor::Paginate::Exceptions::DependencyError unless valid_serializer
+
+          ActiveRecord::Base.transaction do
+            Panko::ArraySerializer.new(paginated_content, each_serializer: serializer).to_a
+          end
+        rescue ActiveRecord::StatementInvalid
+          retry
+        end
+
+        def valid_serializer
+          serializer.respond_to?('_descriptor') && defined?(Panko::Serializer)
+        end
+      end
+    end
+  end
+end

data/lib/wor/paginate/paginate.rb

@@ -2,17 +2,6 @@ require_relative 'utils/preserve_records_helper'
 
 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 = {})
       return render_paginate_with_include(content, options) if includes?(options)
 
@@ -21,18 +10,15 @@ module Wor
 
     def paginate(content, options = {})
       current_url = request.original_url
-
       if (preserve_records = options[:preserve_records])
         content, current_url = Wor::Paginate::Utils::PreserveRecordsHelper
                                .new(content, current_url,
                                     preserve_records.is_a?(Hash) ? preserve_records : {}).call
       end
-
       adapter = find_adapter_for_content(content, options)
       raise Exceptions::NoPaginationAdapter if adapter.blank?
 
-      formatter_class(options).new(adapter, options.merge(_current_url: current_url))
-                              .format
+      formatter_class(options).new(adapter, options.merge(_current_url: current_url)).format
     end
 
     def render_paginate_with_include(content, options)
@@ -40,15 +26,20 @@ module Wor
     end
 
     def formatter_class(options)
-      options[:formatter].presence || Formatter
+      options[:formatter].presence || Config.formatter
     end
 
     def find_adapter_for_content(content, options)
+      return instance_adapter(options[:adapter], content, options) unless options[:adapter].nil?
+
       adapters = []
       adapters << Config.default_adapter if Config.default_adapter.present?
-      adapters += ADAPTERS
-      adapters.map { |adapter| adapter.new(content, page(options), limit(options)) }
-              .find(&:adapt?)
+      adapters += Config.adapters
+      adapters.map { |adapter| instance_adapter(adapter, content, options) }.find(&:adapt?)
+    end
+
+    def instance_adapter(adapter, content, options)
+      adapter.new(content, page(options), limit(options))
     end
 
     def page(options)

data/lib/wor/paginate/rspec.rb

@@ -1,5 +1,7 @@
 class MockedAdapter < Wor::Paginate::Adapters::Base
-  def initialize; end
+  def initialize
+    super(nil, 1, 1)
+  end
 
   def count
     3
@@ -29,7 +31,7 @@ end
 RSpec::Matchers.define :be_paginated do
   match do |actual_response|
     response = parse_response(actual_response)
-    formatter = @custom_formatter || Wor::Paginate::Formatter
+    formatter = @custom_formatter || Wor::Paginate::Formatters::Base
     @formatted_keys = formatter.new(MockedAdapter.new, _current_url: 'http://exaple.com/').format.as_json.keys
     response.keys == @formatted_keys
   end

data/lib/wor/paginate/utils/preserve_modes.rb

@@ -11,8 +11,6 @@ module Wor
             query_param_value ? Time.parse(query_param_value) : now_timestamp
           end
 
-          private_class_method
-
           def self.now_timestamp
             Time.zone.now.iso8601(10)
           end

data/lib/wor/paginate/utils/preserve_records_helper.rb

@@ -25,6 +25,7 @@ module Wor
             by = options[:by]&.to_s || 'timestamp'
             raise ArgumentError, "'by' option should be 'id' or 'timestamp'" unless
               %w[timestamp id].include? by
+
             "Wor::Paginate::Utils::PreserveModes::#{by.classify}".constantize
           end
         end

data/lib/wor/paginate/version.rb

@@ -1,5 +1,5 @@
 module Wor
   module Paginate
-    VERSION = '0.2.0'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/lib/wor/paginate.rb

@@ -5,10 +5,13 @@ 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/dependency_error'
 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/formatters/base'
+require_relative 'paginate/formatters/panko_formatter'
+require_relative 'paginate/formatters/ams_formatter'
 require_relative 'paginate/config'
 require_relative 'paginate/paginate'
 
@@ -17,7 +20,7 @@ module Wor
     def self.configure
       yield Config
 
-      return if ADAPTERS.include?(Config.default_adapter) || Config.default_adapter.nil?
+      return if Config.adapters.any? || Config.default_adapter.present?
 
       raise Exceptions::NoPaginationAdapter
     end

data/wor-paginate.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.date        = Date.today
   s.authors     = ["icoluccio", "mnmallea", "holywyvern", "lucasVoboril"]
   s.email       = ["ignacio.coluccio@wolox.com.ar", "martin.mallea@wolox.com.ar", "ramiro.rojo@wolox.com.ar", "lucas.voboril@wolox.com.ar"]
-  s.homepage    = "https://github.com/Wolox/wor-paginate"
+  s.homepage    = "https://github.com/icoluccio/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"
@@ -19,6 +19,6 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
 
-  s.add_dependency 'railties', '>= 4.1.0'
-  s.add_dependency 'rails', '>= 4.0'
+  s.add_dependency 'railties', '>= 6.1', '< 9'
+  s.add_dependency 'rails', '>= 6.1', '< 9'
 end

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: wor-paginate
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - icoluccio
 - mnmallea
 - holywyvern
 - lucasVoboril
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-13 00:00:00.000000000 Z
+date: 2026-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -19,28 +18,40 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 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
@@ -54,9 +65,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
+- ".overcommit.yml"
 - ".rubocop.yml"
-- ".travis.yml"
+- Appraisals
 - CHANGELOG.md
 - Gemfile
 - LICENSE.md
@@ -74,10 +87,13 @@ files:
 - 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/dependency_error.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/formatters/ams_formatter.rb
+- lib/wor/paginate/formatters/base.rb
+- lib/wor/paginate/formatters/panko_formatter.rb
 - lib/wor/paginate/paginate.rb
 - lib/wor/paginate/rspec.rb
 - lib/wor/paginate/utils/preserve_modes.rb
@@ -85,13 +101,11 @@ files:
 - lib/wor/paginate/utils/uri_helper.rb
 - lib/wor/paginate/version.rb
 - pull_request_template.md
-- test.sqlite3
 - wor-paginate.gemspec
-homepage: https://github.com/Wolox/wor-paginate
+homepage: https://github.com/icoluccio/wor-paginate
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -106,8 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Simplified pagination for Rails API controllers
 test_files: []

data/.travis.yml

@@ -1,24 +0,0 @@
-language: ruby
-rvm:
-  - 2.3.8
-  - 2.4.7
-  - 2.5.6
-  - 2.6.4
-  - 2.7.0
-  - ruby-head
-
-before_install:
-  - gem install bundler -v 2.0.1
-
-install:
-  - bundle _2.0.1_ install --retry=3
-  - bundle exec rake db:migrate RAILS_ENV=test -f spec/dummy/Rakefile
-
-script:
-  - bundle exec rubocop lib spec --format simple
-  - bundle exec rspec
-  - bundle exec codeclimate-test-reporter
-
-matrix:
-  allow_failures:
-    - rvm : ruby-head

data/lib/wor/paginate/formatter.rb

@@ -1,66 +0,0 @@
-require_relative 'utils/uri_helper'
-
-module Wor
-  module Paginate
-    class Formatter
-      include Utils::UriHelper
-      attr_accessor :adapter, :content, :formatter, :options
-
-      def initialize(adapter, options = {})
-        @adapter = adapter
-        @options = options
-      end
-
-      def format # rubocop: disable Metrics/MethodLength
-        {
-          page: serialized_content,
-          count: count,
-          total_pages: total_pages,
-          total_count: options[:total_count] || total_count,
-          current_page: current_page,
-          previous_page: previous_page,
-          next_page: next_page,
-          next_page_url: page_url(next_page),
-          previous_page_url: page_url(previous_page)
-        }
-      end
-
-      protected
-
-      delegate :count, :total_count, :total_pages, :previous_page, :next_page, to: :adapter
-
-      def current_page
-        adapter.page.to_i
-      end
-
-      def paginated_content
-        @content ||= adapter.paginated_content
-      end
-
-      def serialized_content
-        if serializer.present?
-          return paginated_content.map { |item| serializer.new(item, options) }
-        end
-        if defined? ActiveModelSerializers::SerializableResource
-          ActiveModelSerializers::SerializableResource.new(paginated_content).as_json
-        else
-          paginated_content.as_json
-        end
-      end
-
-      def serializer
-        options[:each_serializer]
-      end
-
-      def page_url(page)
-        return nil unless page
-
-        replace_query_params(current_url, page: page)
-      end
-
-      def current_url
-        options[:_current_url]
-      end
-    end
-  end
-end