pagy 43.0.7 → 43.1.4

data/javascripts/pagy.mjs

@@ -23,18 +23,18 @@ const Pagy = (() => {
   }));
   const B64SafeEncode = (unicode) => btoa(String.fromCharCode(...new TextEncoder().encode(unicode))).replace(/[+/=]/g, (m) => m == "+" ? "-" : m == "/" ? "_" : ""), B64Decode = (base64) => new TextDecoder().decode(Uint8Array.from(atob(base64), (c) => c.charCodeAt(0)));
   const randKey = () => Math.floor(Math.random() * 36 ** 3).toString(36);
-  const augmentKeynav = async (nav, [storageKey, pageKey, last, spliceArgs]) => {
-    let augment;
+  const augmentKeynav = async (nav, [storageKey, rootKey, pageKey, last, spliceArgs]) => {
+    let augmentPage;
     const browserKey = document.cookie.split(/;\s+/).find((row) => row.startsWith(pagy + "="))?.split("=")[1] ?? randKey();
     document.cookie = pagy + "=" + browserKey;
     if (storageKey && !(storageKey in storage)) {
       sync.postMessage({ from: tabId, key: storageKey });
       await new Promise((resolve) => setTimeout(() => resolve(""), 100));
       if (!(storageKey in storage)) {
-        augment = (page) => page + "+" + last;
+        augmentPage = (page) => page + "+" + last;
       }
     }
-    if (!augment) {
+    if (!augmentPage) {
       if (!storageKey) {
         do {
           storageKey = randKey();
@@ -45,7 +45,7 @@ const Pagy = (() => {
         cutoffs.splice(...spliceArgs);
         storage.setItem(storageKey, JSON.stringify(cutoffs));
       }
-      augment = (page) => {
+      augmentPage = (page) => {
         const pageNum = parseInt(page);
         return B64SafeEncode(JSON.stringify([
           browserKey,
@@ -57,11 +57,12 @@ const Pagy = (() => {
         ]));
       };
     }
+    const search = rootKey ? `${rootKey}%5B${pageKey}%5D` : pageKey;
+    const re = new RegExp(`(?<=\\?.*)(\\b${search}=)(\\d+)`);
     for (const a of nav.querySelectorAll("a[href]")) {
-      const url = a.href, re = new RegExp(`(?<=\\?.*)\\b${pageKey}=(\\d+)`);
-      a.href = url.replace(re, pageKey + "=" + augment(url.match(re)[1]));
+      a.href = a.href.replace(re, (_match, prefix, digit) => `${prefix}${augmentPage(digit)}`);
     }
-    return augment;
+    return augmentPage;
   };
   const buildNavJs = (nav, [
     [before, anchor, current, gap, after],
@@ -123,7 +124,7 @@ const Pagy = (() => {
     });
   };
   return {
-    version: "43.0.7",
+    version: "43.1.4",
     init(arg) {
       const target = arg instanceof HTMLElement ? arg : document, elements = target.querySelectorAll("[data-pagy]");
       for (const element of elements) {

data/lib/pagy/classes/exceptions.rb

@@ -22,12 +22,4 @@ class Pagy
 
   # Generic internal error
   class InternalError < StandardError; end
-
-  # JsonApi :page param error
-  class JsonapiReservedParamError < StandardError
-    # Inform about the actual value
-    def initialize(value)
-      super("expected reserved :page param to be nil or Hash-like; got #{value.inspect}")
-    end
-  end
 end

data/lib/pagy/classes/keyset/keynav.rb

@@ -27,6 +27,7 @@ class Pagy
       # Prepare the @update for the client when it's a new page, and return the next page number
       def next
         records
+        @count = 0 if !@more && @page == 1  # empty records (trigger the right info message for known 0 count)
         return if !@more || (@options[:max_pages] && @page >= @options[:max_pages])
 
         @next ||= begin
@@ -50,7 +51,7 @@ class Pagy
         else
           @page = @last = 1
         end
-        @update = [storage_key, @options[:page_key]]
+        @update = [storage_key, @options[:root_key], @options[:page_key]]
       end
 
       # Use a compound predicate to fetch the records

data/lib/pagy/classes/offset/countless.rb

@@ -8,7 +8,7 @@ class Pagy
         assign_options(**)
         assign_and_check(limit: 1, page: 1)
         @page = upto_max_pages(@page)
-        assign_last
+        @last = upto_max_pages(@options[:last]) unless @options[:headless]
         assign_offset
       end
 
@@ -25,32 +25,37 @@ class Pagy
       def countless? = true
 
       def upto_max_pages(value)
-        return value unless @options[:max_pages]
+        return value unless value && @options[:max_pages]
 
         [value, @options[:max_pages]].min
       end
 
-      def assign_last
-        return unless @options[:last]
-
-        @last = upto_max_pages(@options[:last].to_i)
-      end
-
       # Finalize the instance variables based on the fetched size
       def finalize(fetched_size)
+        # empty records (trigger the right info message for known 0 count)
+        @count = 0 if fetched_size.zero? && @page == 1
         return self unless in_range? { fetched_size.positive? || @page == 1 }
 
-        if @last && @page < @last # visited page
-          @last = @page unless fetched_size > @limit # set last if last page
-        else
-          @last = upto_max_pages(fetched_size > @limit ? @page + 1 : @page)
-        end
+        past  = @last && @page < @last # this page has been past
+        more  = fetched_size > @limit  # more pages after this one
+        @last = upto_max_pages(more ? @page + 1 : @page) unless past && more
         @in   = [fetched_size, @limit].min
         @from = @in.zero? ? 0 : @offset + 1
         @to   = @offset + @in
         assign_previous_and_next
         self
       end
+
+      # Called by false in_range?
+      def assign_empty_page_variables
+        @in = @from = @to = 0
+        target_last = [@page - 1, 1].max
+        @last       = [@last || target_last, target_last].min
+        @previous   = @last
+      end
+
+      # Support easy countless page param overriding (for legacy param and behavior)
+      def compose_page_param(page) = "#{page || 1}+#{@last}"
     end
   end
 end

data/lib/pagy/classes/request.rb

@@ -1,37 +1,36 @@
 # frozen_string_literal: true
 
 class Pagy
-  # Decouple the reuest from the env, allowing non-rack apps to use pagy by passing a hash.
-  # Resolve :page and :limit, supporting the :jsonapi option. Support for URL composition.
-  #
+  # Decouple the request from the env, allowing non-rack apps to use pagy by passing a hash.
+  # Resolve the :page and :limit options from params.
   class Request
-    def initialize(request, options = {})
+    def initialize(options)
+      @options = options
+      request  = @options[:request]
       @base_url, @path, @params, @cookie =
         if request.is_a?(Hash)
           request.values_at(:base_url, :path, :params, :cookie)
         else
           [request.base_url, request.path, request.GET.merge(request.POST), request.cookies['pagy']]
         end
-      @jsonapi = @params['page'] && options[:jsonapi]
-      raise JsonapiReservedParamError, @params['page'] if @jsonapi && !@params['page'].respond_to?(:fetch)
     end
 
     attr_reader :base_url, :path, :params, :cookie
 
-    def resolve_page(options, force_integer: true)
-      page_key = options[:page_key] || DEFAULT[:page_key]
-      page     = @jsonapi ? @params['page'][page_key] : @params[page_key]
+    def resolve_page(force_integer: true)
+      page_key = @options[:page_key] || DEFAULT[:page_key]
+      page     = @params.dig(@options[:root_key], page_key) || @params[page_key]
       page     = nil if page == ''   # fix for app-generated queries like ?page=
       force_integer ? (page || 1).to_i : page
     end
 
-    def resolve_limit(options)
-      limit_key = options[:limit_key] || DEFAULT[:limit_key]
-      return options[:limit] || DEFAULT[:limit] \
-             unless options[:client_max_limit] &&
-                    (requested_limit = @jsonapi ? @params['page'][limit_key] : @params[limit_key])
+    def resolve_limit
+      limit_key = @options[:limit_key] || DEFAULT[:limit_key]
+      return @options[:limit] || DEFAULT[:limit] \
+             unless @options[:client_max_limit] &&
+                    (requested_limit = @params.dig(@options[:root_key], limit_key) || @params[limit_key])
 
-      [requested_limit.to_i, options[:client_max_limit]].min
+      [requested_limit.to_i, @options[:client_max_limit]].min
     end
   end
 end

data/lib/pagy/modules/abilities/linkable.rb

@@ -9,25 +9,22 @@ class Pagy
       module_function
 
       # Extracted from Rack::Utils and reformatted for rubocop
-      # Add the 'unescaped' param, and use it for simple and safe url-templating.
-      # All string keyed hashes
-      def build_nested_query(value, prefix = nil, unescaped = [])
+      # Allow unescaped Pagy::RawQueryValue
+      def build_nested_query(value, prefix = nil)
         case value
         when Array
-          value.map { |v| build_nested_query(v, "#{prefix}[]", unescaped) }.join('&')
+          value.map { |v| build_nested_query(v, "#{prefix}[]") }.join('&')
         when Hash
           value.map do |k, v|
-            new_k = prefix ? "#{prefix}[#{escape(k)}]" : escape(k)
-            unescaped[unescaped.find_index(k)] = new_k if unescaped.size.positive? && new_k != k && unescaped.include?(k)
-            build_nested_query(v, new_k, unescaped)
+            build_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
           end.delete_if(&:empty?).join('&')
         when nil
           escape(prefix)
         else
           raise ArgumentError, 'value must be a Hash' if prefix.nil?
-          return "#{escape(prefix)}=#{value}" if unescaped.include?(prefix)
 
-          "#{escape(prefix)}=#{escape(value)}"
+          final_value = value.is_a?(RawQueryValue) ? value.to_s : escape(value)
+          "#{escape(prefix)}=#{final_value}"
         end
       end
 
@@ -40,18 +37,18 @@ class Pagy
 
     # Return the URL for the page, relying on the Pagy::Request
     def compose_page_url(page, limit_token: nil, **options)
-      jsonapi, page_key, limit_key, limit, client_max_limit, querify, absolute, path, fragment =
+      root_key, page_key, limit_key, limit, client_max_limit, querify, absolute, path, fragment =
         @options.merge(options)
-                .values_at(:jsonapi, :page_key, :limit_key, :limit, :client_max_limit, :querify, :absolute, :path, :fragment)
+                .values_at(:root_key, :page_key, :limit_key, :limit, :client_max_limit, :querify, :absolute, :path, :fragment)
       params = @request.params.clone(freeze: false)
-      params.delete(jsonapi ? 'page' : page_key)
+      params.delete(root_key || page_key)
       factors = {}.tap do |h|
-                  h[page_key]  = countless? ? "#{page || 1}+#{@last}" : page
+                  h[page_key]  = countless? ? RawQueryValue.new(compose_page_param(page)) : page
                   h[limit_key] = limit_token || limit if client_max_limit
                 end.compact # No empty params
-      params.merge!(jsonapi ? { 'page' => factors } : factors) if factors.size.positive?
+      params.merge!(root_key ? { root_key => factors } : factors) if factors.size.positive?
       querify&.(params) # Must modify the params: the returned value is ignored
-      query_string = QueryUtils.build_nested_query(params, nil, [page_key, limit_key])
+      query_string = QueryUtils.build_nested_query(params)
       query_string = "?#{query_string}" unless query_string.empty?
       fragment   &&= %(##{fragment}) unless fragment&.start_with?('#')
       "#{@request.base_url if absolute}#{path || @request.path}#{query_string}#{fragment}"

data/lib/pagy/modules/abilities/rangeable.rb

@@ -5,11 +5,12 @@ class Pagy
   module Rangeable
     # Check if in range
     def in_range?
-      return @in_range if defined?(@in_range) || (@in_range = yield)
+      return @in_range if defined?(@in_range)
+      return true if (@in_range = yield)
       raise RangeError.new(self, :page, "in 1..#{@last}", @page) if @options[:raise_range_error]
 
       assign_empty_page_variables
-      false
+      @in_range = false
     end
   end
 end

data/lib/pagy/modules/console.rb

@@ -3,20 +3,6 @@
 class Pagy
   # Provide a ready to use pagy environment when included in irb/rails console
   module Console
-    class Request
-      attr_accessor :base_url, :path, :params
-
-      def initialize
-        @base_url = 'http://www.example.com'
-        @path     = '/path'
-        @params   = { example: '123' }
-      end
-
-      def GET = @params  # rubocop:disable Naming/MethodName
-
-      def cookies = {}
-    end
-
     class Collection < Array
       def initialize(arr = Array(1..1000))
         super
@@ -31,8 +17,8 @@ class Pagy
     include Method
 
     # Direct reference to request.params via a method
-    def params     = request.params
-    def request    = @request ||= Request.new
+    def request    = @request ||= { base_url: 'http://www.example.com', path: '/path', params: { example: '123' } }
+    def params     = request[:params]
     def collection = Collection
   end
 end

data/lib/pagy/modules/searcher.rb

@@ -6,13 +6,11 @@ class Pagy
     module_function
 
     # Common search logic
-    def wrap(context, pagy_search_args, options)
-      context.instance_exec do
-        options[:page]  ||= options[:request].resolve_page(options)
-        options[:limit] ||= options[:request].resolve_limit(options)
-      end
-      pagy, results = yield
-      calling = pagy_search_args[4..]
+    def wrap(pagy_search_args, options)
+      options[:page] ||= options[:request].resolve_page
+      options[:limit]  = options[:request].resolve_limit
+      pagy, results    = yield
+      calling          = pagy_search_args[4..]
       [pagy, calling.empty? ? results : results.send(*calling)]
     end
   end

data/lib/pagy/toolbox/helpers/support/a_lambda.rb

@@ -18,7 +18,7 @@ class Pagy
                     %( #{anchor_string}) if anchor_string}).split(PAGE_TOKEN, 2)
 
     lambda do |page, text = page_label(page), classes: nil, aria_label: nil|
-      title = if (counts = @options[:counts]) # only for calendar + counts
+      title = if (counts = @options[:counts]) # only for calendar with counts
                 count    = counts[page - 1]
                 classes  = classes ? "#{classes} empty-page" : 'empty-page' if count.zero?
                 info_key = count.zero? ? 'pagy.info_tag.no_items' : 'pagy.info_tag.single_page'

data/lib/pagy/toolbox/paginators/calendar.rb

@@ -11,7 +11,6 @@ class Pagy
         raise ArgumentError, "keys must be in #{allowed_options.inspect}" \
               unless config.is_a?(Hash) && (config.keys - allowed_options).empty?
 
-        config[:request]  = Request.new(config[:request] || request)
         config[:offset] ||= {}
         unless config[:disabled]
           calendar, from, to =

data/lib/pagy/toolbox/paginators/countless.rb

@@ -4,22 +4,17 @@ class Pagy
   module CountlessPaginator
     module_function
 
-    # Return Pagy object and records
-    def paginate(context, collection, **options)
-      context.instance_eval do
-        request = Request.new(options[:request] || self.request, options)
-        if options[:page].nil?
-          page = request.resolve_page(options, force_integer: false) # accept nil and strings
-          if page.is_a?(String)
-            p, l = page.split(/ /, 2).map(&:to_i)
-            options[:page] = p if p.positive?
-            options[:last] = l if l&.positive?
-          end
-        end
-        options[:limit] = request.resolve_limit(options)
-        pagy = Offset::Countless.new(**options, request:)
-        [pagy, pagy.records(collection)]
+    # Return the Offset::Countless instance and records
+    def paginate(collection, options)
+      options[:page] ||= options[:request].resolve_page(force_integer: false) # accept nil and strings
+      if options[:page].is_a?(String)
+        page, last     = options[:page].split(/ /, 2).map(&:to_i) # decoded '+' added by the compose_page_url
+        options[:page] = page
+        options[:last] = last if last&.positive?
       end
+      options[:limit] = options[:request].resolve_limit
+      pagy            = Offset::Countless.new(**options)
+      [pagy, pagy.records(collection)]
     end
   end
 end

data/lib/pagy/toolbox/paginators/elasticsearch_rails.rb

@@ -7,26 +7,23 @@ class Pagy
     module_function
 
     # Paginate from the search object
-    def paginate(context, search, **options)
-      context.instance_eval do
-        options[:request] = Request.new(options[:request] || request, options)
-        if search.is_a?(Search::Arguments)
-          # The search is the array of pagy_search arguments
-          Searcher.wrap(self, search, options) do
-            model, query_or_payload, search_options = search
-            search_options[:size] = options[:limit]
-            search_options[:from] = options[:limit] * ((options[:page] || 1) - 1)
-            results               = model.send(ElasticsearchRails::DEFAULT[:search_method], query_or_payload, **search_options)
-            options[:count]       = ElasticsearchRails.total_count(results)
-            [ElasticsearchRails.new(**options), results]
-          end
-        else
-          # The search is an elasticsearch_rails response
-          options[:limit] = search.search.options[:size] || 10
-          options[:page]  = ((search.search.options[:from] || 0) / options[:limit]) + 1
-          options[:count] = ElasticsearchRails.total_count(search)
-          ElasticsearchRails.new(**options)
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments)
+        # The search is the array of pagy_search arguments
+        Searcher.wrap(search, options) do
+          model, query_or_payload, search_options = search
+          search_options[:size] = options[:limit]
+          search_options[:from] = options[:limit] * ((options[:page] || 1) - 1)
+          results               = model.send(ElasticsearchRails::DEFAULT[:search_method], query_or_payload, **search_options)
+          options[:count]       = ElasticsearchRails.total_count(results)
+          [ElasticsearchRails.new(**options), results]
         end
+      else
+        # The search is an elasticsearch_rails response
+        options[:limit] = search.search.options[:size] || 10
+        options[:page]  = ((search.search.options[:from] || 0) / options[:limit]) + 1
+        options[:count] = ElasticsearchRails.total_count(search)
+        ElasticsearchRails.new(**options)
       end
     end
   end

data/lib/pagy/toolbox/paginators/keynav_js.rb

@@ -6,24 +6,21 @@ class Pagy
   module KeynavJsPaginator
     module_function
 
-    # Return Pagy::Keyset::Keynav object and paginated records.
+    # Return the Pagy::Keyset::Keynav instance and paginated records.
     # Fall back to :countless if the :page has no client data.
-    def paginate(context, set, **options)
-      context.instance_eval do
-        request = Request.new(options[:request] || self.request, options)
-        page    = request.resolve_page(options, force_integer: false) # allow nil
-        if page&.match(' ')       # countless page -> no augmentation -> fallback
-          return pagy(:countless, set, page:, **options)
-        elsif page.is_a?(String)  # keynav page param
-          page_arguments = JSON.parse(B64.urlsafe_decode(page))
-          # Restart the pagination from page 1 if the url has been requested from another browser
-          options[:page] = page_arguments if request.cookie == page_arguments.shift
-        end
-
-        options[:limit] = request.resolve_limit(options)
-        pagy = Keyset::Keynav.new(set, **options, request:)
-        [pagy, pagy.records]
+    def paginate(set, options)
+      page = options[:request].resolve_page(force_integer: false) # allow nil
+      if page&.match(' ')       # countless page -> no augmentation -> fallback
+        return CountlessPaginator.paginate(set, page:, **options)
+      elsif page.is_a?(String)  # keynav page param
+        page_arguments = JSON.parse(B64.urlsafe_decode(page))
+        # Restart the pagination from page 1/nil if the url has been requested from another browser
+        options[:page] = page_arguments if options[:request].cookie == page_arguments.shift
       end
+
+      options[:limit] = options[:request].resolve_limit
+      pagy = Keyset::Keynav.new(set, **options)
+      [pagy, pagy.records]
     end
   end
 end

data/lib/pagy/toolbox/paginators/keyset.rb

@@ -4,15 +4,12 @@ class Pagy
   module KeysetPaginator
     module_function
 
-    # Return Pagy::Keyset object and paginated records
-    def paginate(context, set, **options)
-      context.instance_eval do
-        request = Request.new(options[:request] || self.request, options)
-        options[:page] ||= request.resolve_page(options, force_integer: false) # allow nil
-        options[:limit]  = request.resolve_limit(options)
-        pagy = Keyset.new(set, **options, request:)
-        [pagy, pagy.records]
-      end
+    # Return Pagy::Keyset instance and paginated records
+    def paginate(set, options)
+      options[:page] ||= options[:request].resolve_page(force_integer: false) # allow nil
+      options[:limit]  = options[:request].resolve_limit
+      pagy = Keyset.new(set, **options)
+      [pagy, pagy.records]
     end
   end
 end

data/lib/pagy/toolbox/paginators/meilisearch.rb

@@ -7,26 +7,23 @@ class Pagy
     module_function
 
     # Paginate from the search object
-    def paginate(context, search, **options)
-      context.instance_eval do
-        options[:request] = Request.new(options[:request] || request, options)
-        if search.is_a?(Search::Arguments)
-          # The search is the array of pagy_search arguments
-          Searcher.wrap(self, search, options) do
-            model, term, search_options    = search
-            search_options[:hits_per_page] = options[:limit]
-            search_options[:page]          = options[:page]
-            results                        = model.send(Meilisearch::DEFAULT[:search_method], term, search_options)
-            options[:count]                = results.raw_answer['totalHits']
-            [Meilisearch.new(**options), results]
-          end
-        else
-          # The search is a meilisearch results object
-          options[:limit] = search.raw_answer['hitsPerPage']
-          options[:page]  = search.raw_answer['page']
-          options[:count] = search.raw_answer['totalHits']
-          Meilisearch.new(**options)
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments)
+        # The search is the array of pagy_search arguments
+        Searcher.wrap(search, options) do
+          model, term, search_options    = search
+          search_options[:hits_per_page] = options[:limit]
+          search_options[:page]          = options[:page]
+          results                        = model.send(Meilisearch::DEFAULT[:search_method], term, search_options)
+          options[:count]                = results.raw_answer['totalHits']
+          [Meilisearch.new(**options), results]
         end
+      else
+        # The search is a meilisearch results object
+        options[:limit] = search.raw_answer['hitsPerPage']
+        options[:page]  = search.raw_answer['page']
+        options[:count] = search.raw_answer['totalHits']
+        Meilisearch.new(**options)
       end
     end
   end

data/lib/pagy/toolbox/paginators/method.rb

@@ -15,13 +15,20 @@ class Pagy
   path = Pathname.new(__dir__)
   paginators.each { |symbol, name| autoload name, path.join(symbol.to_s) }
 
-  # Defines the pagy method. Include in the app controller/view.
+  # Pagy::Method defines the #pagy method to be included in the app controller/view.
   Method = Module.new do
              protected
 
              define_method :pagy do |paginator = :offset, collection, **options|
-               merged_options = paginator == :calendar ? options : Pagy.options.merge(options)
-               Pagy.const_get(paginators[paginator]).paginate(self, collection, **merged_options)
+               arguments = if paginator == :calendar
+                             [self, collection, options]
+                           else
+                             [collection, options = Pagy.options.merge(options)]
+                           end
+               options[:root_key]  = 'page' if options[:jsonapi] # enforce 'page' root_key for JSON:API
+               options[:request] ||= request                     # user set request or self.request
+               options[:request]   = Request.new(options)        # Pagy::Request
+               Pagy.const_get(paginators[paginator]).paginate(*arguments)
              end
            end
 end

data/lib/pagy/toolbox/paginators/offset.rb

@@ -4,16 +4,13 @@ class Pagy
   module OffsetPaginator
     module_function
 
-    # Return instance and page of results
-    def paginate(context, collection, **options)
-      context.instance_eval do
-        request = Request.new(options[:request] || self.request, options)
-        options[:page]  ||= request.resolve_page(options)
-        options[:limit]   = request.resolve_limit(options)
-        options[:count] ||= collection.instance_of?(Array) ? collection.size : OffsetPaginator.get_count(collection, options)
-        pagy = Offset.new(**options, request:)
-        [pagy, collection.instance_of?(Array) ? collection[pagy.offset, pagy.limit] : pagy.records(collection)]
-      end
+    # Return the Pagy::Offset instance and results
+    def paginate(collection, options)
+      options[:page]  ||= options[:request].resolve_page
+      options[:limit]   = options[:request].resolve_limit
+      options[:count] ||= collection.instance_of?(Array) ? collection.size : OffsetPaginator.get_count(collection, options)
+      pagy = Offset.new(**options)
+      [pagy, collection.instance_of?(Array) ? collection[pagy.offset, pagy.limit] : pagy.records(collection)]
     end
 
     # Get the collection count

data/lib/pagy/toolbox/paginators/searchkick.rb

@@ -7,26 +7,23 @@ class Pagy
     module_function
 
     # Paginate from the search object
-    def paginate(context, search, **options)
-      context.instance_eval do
-        options[:request] = Request.new(options[:request] || request, options)
-        if search.is_a?(Search::Arguments)
-          # The search is the array of pagy_search arguments
-          Searcher.wrap(self, search, options) do
-            model, term, search_options, block = search
-            search_options[:per_page] = options[:limit]
-            search_options[:page]     = options[:page]
-            results                   = model.send(Searchkick::DEFAULT[:search_method], term || '*', **search_options, &block)
-            options[:count]           = results.total_count
-            [Searchkick.new(**options), results]
-          end
-        else
-          # The search is a searchkick results object
-          options[:limit] = search.respond_to?(:options) ? search.options[:per_page] : search.per_page
-          options[:page]  = search.respond_to?(:options) ? search.options[:page]     : search.current_page
-          options[:count] = search.total_count
-          Searchkick.new(**options)
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments)
+        # The search is the array of pagy_search arguments
+        Searcher.wrap(search, options) do
+          model, term, search_options, block = search
+          search_options[:per_page] = options[:limit]
+          search_options[:page]     = options[:page]
+          results                   = model.send(Searchkick::DEFAULT[:search_method], term || '*', **search_options, &block)
+          options[:count]           = results.total_count
+          [Searchkick.new(**options), results]
         end
+      else
+        # The search is a searchkick results object
+        options[:limit] = search.respond_to?(:options) ? search.options[:per_page] : search.per_page
+        options[:page]  = search.respond_to?(:options) ? search.options[:page]     : search.current_page
+        options[:count] = search.total_count
+        Searchkick.new(**options)
       end
     end
   end