pagy 3.10.0 → 5.7.3

data/lib/pagy/extras/items.rb

@@ -1,65 +1,54 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/items
-# encoding: utf-8
 # frozen_string_literal: true
 
-require 'pagy/extras/shared'
+require 'pagy/extras/frontend_helpers'
 
-class Pagy
+class Pagy # :nodoc:
+  DEFAULT[:items_param] = :items
+  DEFAULT[:max_items]   = 100
+  DEFAULT[:items_extra] = true   # extra enabled by default
 
-  # Default variables for this extra
-  VARS[:items_param] = :items
-  VARS[:max_items]   = 100
+  # Allow the client to request a custom number of items per page with an optional selector UI
+  module ItemsExtra
+    # Additions for the Backend module
+    module Backend
+      private
 
-  ITEMS_PLACEHOLDER = '__pagy_items__'
+      # Set the items variable considering the params and other pagy variables
+      def pagy_set_items_from_params(vars)
+        return if vars[:items]                                                             # :items explicitly set
+        return unless vars.key?(:items_extra) ? vars[:items_extra] : DEFAULT[:items_extra] # :items_extra is false
+        return unless (items = params[vars[:items_param] || DEFAULT[:items_param]])        # no items from request params
 
-  # Handle a custom number of :items from params
-  module Backend ; private
-
-    def pagy_with_items(vars)
-      vars[:items] ||= (items = params[vars[:items_param] || VARS[:items_param]]) &&                           # :items from :items_param
-                       [items.to_i, vars.key?(:max_items) ? vars[:max_items] : VARS[:max_items]].compact.min   # :items capped to :max_items
-    end
-
-    # add the pagy*_get_vars alias-chained methods for frontend, and defined/required extras
-    [nil, 'countless', 'elasticsearch_rails', 'searchkick'].each do |name|
-      prefix, if_start, if_end = "_#{name}", "if defined?(Pagy::#{name.upcase})", "end" if name
-      module_eval <<-RUBY
-        #{if_start}
-          alias_method :pagy#{prefix}_get_vars_without_items, :pagy#{prefix}_get_vars
-          def pagy#{prefix}_get_vars_with_items(collection, vars)
-            pagy_with_items(vars)
-            pagy#{prefix}_get_vars_without_items(collection, vars)
-          end
-          alias_method :pagy#{prefix}_get_vars, :pagy#{prefix}_get_vars_with_items  
-        #{if_end}
-      RUBY
-    end
-
-  end
-
-  module Frontend
-
-    alias_method :pagy_url_for_without_items, :pagy_url_for
-    def pagy_url_for_with_items(page, pagy, url=false)
-      p_vars = pagy.vars; params = request.GET.merge(p_vars[:params]); params[p_vars[:page_param].to_s] = page
-      params[p_vars[:items_param].to_s] = p_vars[:items]
-      "#{request.base_url if url}#{request.path}?#{Rack::Utils.build_nested_query(pagy_get_params(params))}#{p_vars[:anchor]}"
+        vars[:items] = [items.to_i, vars.key?(:max_items) ? vars[:max_items] : DEFAULT[:max_items]].compact.min
+      end
     end
-    alias_method :pagy_url_for, :pagy_url_for_with_items
 
-    # Return the items selector HTML. For example "Show [20] items per page"
-    def pagy_items_selector_js(pagy, id=pagy_id)
-      p_vars         = pagy.vars
-      p_items        = p_vars[:items]
-      p_vars[:items] = ITEMS_PLACEHOLDER
-      link           = pagy_marked_link(pagy_link_proc(pagy))
-      p_vars[:items] = p_items # restore the items
-
-      html = EMPTY + %(<span id="#{id}">)
-      input = %(<input type="number" min="1" max="#{p_vars[:max_items]}" value="#{p_items}" style="padding: 0; text-align: center; width: #{p_items.to_s.length+1}rem;">)
-      html << %(#{pagy_t('pagy.items_selector_js', item_name: pagy_t(p_vars[:i18n_key], count: p_items), items_input: input, count: p_items)})
-      html << %(</span>#{pagy_json_tag(:items_selector, id, pagy.from, link, defined?(TRIM) && p_vars[:page_param])})
+    # Additions for the Frontend module
+    module Frontend
+      ITEMS_PLACEHOLDER = '__pagy_items__'
+
+      # Return the items selector HTML. For example "Show [20] items per page"
+      def pagy_items_selector_js(pagy, pagy_id: nil, item_name: nil, i18n_key: nil, link_extra: '')
+        return '' unless pagy.vars[:items_extra]
+
+        p_id           = %( id="#{pagy_id}") if pagy_id
+        p_vars         = pagy.vars
+        p_items        = p_vars[:items]
+        p_vars[:items] = ITEMS_PLACEHOLDER
+        link           = pagy_marked_link(pagy_link_proc(pagy, link_extra: link_extra))
+        p_vars[:items] = p_items # restore the items
+
+        html  = +%(<span#{p_id} class="pagy-items-selector-js" #{pagy_json_attr pagy, :selector, pagy.from, link}>)
+        input = %(<input type="number" min="1" max="#{p_vars[:max_items]}" value="#{
+                    p_items}" style="padding: 0; text-align: center; width: #{p_items.to_s.length + 1}rem;">)
+        html << pagy_t('pagy.items_selector_js', item_name: item_name || pagy_t(i18n_key || p_vars[:i18n_key], count: p_items),
+                                                 items_input: input,
+                                                 count: p_items)
+        html << %(</span>)
+      end
     end
-
   end
+  Backend.prepend ItemsExtra::Backend
+  Frontend.prepend ItemsExtra::Frontend
 end

data/lib/pagy/extras/materialize.rb

@@ -1,59 +1,84 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/materialize
-# encoding: utf-8
 # frozen_string_literal: true
 
-require 'pagy/extras/shared'
-
-class Pagy
-  module Frontend
+require 'pagy/extras/frontend_helpers'
 
+class Pagy # :nodoc:
+  # Frontend modules are specially optimized for performance.
+  # The resulting code may not look very elegant, but produces the best benchmarks
+  module MaterializeExtra
     # Pagination for materialize: it returns the html with the series of links to the pages
-    def pagy_materialize_nav(pagy)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
-      html = EMPTY + (p_prev ? %(<li class="waves-effect prev">#{link.call p_prev, '<i class="material-icons">chevron_left</i>', 'aria-label="previous"'}</li>)
-                             : %(<li class="prev disabled"><a href="#"><i class="material-icons">chevron_left</i></a></li>))
-      pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
-        html << if    item.is_a?(Integer); %(<li class="waves-effect">#{link.call item}</li>)                                             # page link
-                elsif item.is_a?(String) ; %(<li class="active">#{link.call item}</li>)                                                   # active page
-                elsif item == :gap       ; %(<li class="gap disabled"><a href="#">#{pagy_t('pagy.nav.gap')}</a></li>)   # page gap
+    def pagy_materialize_nav(pagy, pagy_id: nil, link_extra: '', **vars)
+      p_id = %( id="#{pagy_id}") if pagy_id
+      link = pagy_link_proc(pagy, link_extra: link_extra)
+
+      html = +%(<div#{p_id} class="pagy-materialize-nav pagination" role="navigation" aria-label="pager"><ul class="pagination">)
+      html << pagy_materialize_prev_html(pagy, link)
+      pagy.series(**vars).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+        html << case item
+                when Integer then %(<li class="waves-effect">#{link.call item}</li>)                           # page link
+                when String  then %(<li class="active">#{link.call item}</li>)                                 # active page
+                when :gap    then %(<li class="gap disabled"><a href="#">#{pagy_t 'pagy.nav.gap'}</a></li>)    # page gap
+                else raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
                 end
       end
-      html << (p_next ? %(<li class="waves-effect next">#{link.call p_next, '<i class="material-icons">chevron_right</i>', 'aria-label="next"'}</li>)
-                      : %(<li class="next disabled"><a href="#"><i class="material-icons">chevron_right</i></a></li>))
-      %(<div class="pagy-materialize-nav pagination" role="navigation" aria-label="pager"><ul class="pagination">#{html}</ul></div>)
+      html << pagy_materialize_next_html(pagy, link)
+      html << %(</ul></div>)
     end
 
-    # Javascript pagination for materialize: it returns a nav and a JSON tag used by the Pagy.nav javascript
-    def pagy_materialize_nav_js(pagy, id=pagy_id)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
-      tags = { 'before' => ( '<ul class="pagination">' \
-                           + (p_prev  ? %(<li class="waves-effect prev">#{link.call(p_prev, '<i class="material-icons">chevron_left</i>', 'aria-label="previous"')}</li>)
-                                      : %(<li class="prev disabled"><a href="#"><i class="material-icons">chevron_left</i></a></li>)) ),
-               'link'   => %(<li class="waves-effect">#{mark = link.call(PAGE_PLACEHOLDER)}</li>),
+    # Javascript pagination for materialize: it returns a nav and a JSON tag used by the pagy.js file
+    def pagy_materialize_nav_js(pagy, pagy_id: nil, link_extra: '', **vars)
+      sequels = pagy.sequels(**vars)
+      p_id = %( id="#{pagy_id}") if pagy_id
+      link = pagy_link_proc(pagy, link_extra: link_extra)
+
+      tags = { 'before' => %(<ul class="pagination">#{pagy_materialize_prev_html pagy, link}),
+               'link'   => %(<li class="waves-effect">#{mark = link.call(PAGE_PLACEHOLDER, LABEL_PLACEHOLDER)}</li>),
                'active' => %(<li class="active">#{mark}</li>),
-               'gap'    => %(<li class="gap disabled"><a href="#">#{pagy_t('pagy.nav.gap')}</a></li>),
-               'after'  => ( (p_next ? %(<li class="waves-effect next">#{link.call(p_next, '<i class="material-icons">chevron_right</i>', 'aria-label="next"')}</li>)
-                                     : %(<li class="next disabled"><a href="#"><i class="material-icons">chevron_right</i></a></li>)) \
-                           + '</ul>' ) }
-      %(<div id="#{id}" class="pagy-materialize-nav-js" role="navigation" aria-label="pager"></div>#{pagy_json_tag(:nav, id, tags, pagy.sequels, defined?(TRIM) && pagy.vars[:page_param])})
+               'gap'    => %(<li class="gap disabled"><a href="#">#{pagy_t 'pagy.nav.gap'}</a></li>),
+               'after'  => %(#{pagy_materialize_next_html pagy, link}</ul>) }
+
+      %(<div#{p_id} class="#{'pagy-rjs ' if sequels.size > 1}pagy-materialize-nav-js" role="navigation" aria-label="pager" #{
+        pagy_json_attr(pagy, :nav, tags, sequels, pagy.label_sequels(sequels))}></div>)
     end
 
-    # Javascript combo pagination for materialize: it returns a nav and a JSON tag used by the Pagy.combo_nav javascript
-    def pagy_materialize_combo_nav_js(pagy, id=pagy_id)
-      link, p_prev, p_next, p_page, p_pages = pagy_link_proc(pagy), pagy.prev, pagy.next, pagy.page, pagy.pages
-
-      html = %(<div id="#{id}" class="pagy-materialize-combo-nav-js pagination" role="navigation" aria-label="pager">) \
-           + %(<div class="pagy-compact-chip role="group" style="height: 35px; border-radius: 18px; background: #e4e4e4; display: inline-block;">)
-      html << '<ul class="pagination" style="margin: 0px;">'
-      li_style = 'style="vertical-align: middle;"'
-      html << (p_prev ? %(<li class="waves-effect prev" #{li_style}>#{link.call p_prev, '<i class="material-icons">chevron_left</i>', 'aria-label="previous"'}</li>)
-                      : %(<li class="prev disabled" #{li_style}><a href="#"><i class="material-icons">chevron_left</i></a></li>))
-      input = %(<input type="number" class="browser-default" min="1" max="#{p_pages}" value="#{p_page}" style="padding: 2px; border: none; border-radius: 2px; text-align: center; width: #{p_pages.to_s.length+1}rem;">)
-      html << %(<div class="pagy-combo-input btn-flat" style="cursor: default; padding: 0px">#{pagy_t('pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages)}</div>)
-      html << (p_next ? %(<li class="waves-effect next" #{li_style}>#{link.call p_next, '<i class="material-icons">chevron_right</i>', 'aria-label="next"'}</li>)
-                      : %(<li class="next disabled" #{li_style}><a href="#"><i class="material-icons">chevron_right</i></a></li>))
-      html << %(</ul></div>#{pagy_json_tag(:combo_nav, id, p_page, pagy_marked_link(link), defined?(TRIM) && pagy.vars[:page_param])})
+    # Javascript combo pagination for materialize: it returns a nav and a JSON tag used by the pagy.js file
+    def pagy_materialize_combo_nav_js(pagy, pagy_id: nil, link_extra: '')
+      p_id    = %( id="#{pagy_id}") if pagy_id
+      link    = pagy_link_proc(pagy, link_extra: link_extra)
+      p_page  = pagy.page
+      p_pages = pagy.pages
+      style   = ' style="vertical-align: middle"'
+      input   = %(<input type="number" class="browser-default" min="1" max="#{p_pages}" value="#{
+                    p_page}" style="text-align: center; width: #{p_pages.to_s.length + 1}rem;">)
+
+      html = %(<ul#{p_id} class="pagy-materialize-combo-nav-js pagination chip" role="navigation")
+      %(#{html} aria-label="pager" style="padding-right: 0" #{
+          pagy_json_attr pagy, :combo, pagy_marked_link(link)}>#{
+          pagy_materialize_prev_html pagy, link, style}<li class="pagy-combo-input">#{
+          pagy_t 'pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages}</li>#{
+          pagy_materialize_next_html pagy, link, style}</ul>)
     end
 
+    private
+
+    def pagy_materialize_prev_html(pagy, link, style = '')
+      if (p_prev = pagy.prev)
+        %(<li class="waves-effect prev"#{style}>#{
+            link.call p_prev, '<i class="material-icons">chevron_left</i>', 'aria-label="previous"'}</li>)
+      else
+        %(<li class="prev disabled"#{style}><a href="#"><i class="material-icons">chevron_left</i></a></li>)
+      end
+    end
+
+    def pagy_materialize_next_html(pagy, link, style = '')
+      if (p_next = pagy.next)
+        %(<li class="waves-effect next"#{style}>#{
+            link.call p_next, '<i class="material-icons">chevron_right</i>', 'aria-label="next"'}</li>)
+      else
+        %(<li class="next disabled"#{style}><a href="#"><i class="material-icons">chevron_right</i></a></li>)
+      end
+    end
   end
+  Frontend.prepend MaterializeExtra
 end

data/lib/pagy/extras/meilisearch.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Pagy # :nodoc:
+  DEFAULT[:meilisearch_search_method] ||= :pagy_search
+
+  # Paginate Meilisearch results
+  module MeilisearchExtra
+    module Meilisearch # :nodoc:
+      # Return an array used to delay the call of #search
+      # after the pagination variables are merged to the options
+      def pagy_meilisearch(term = nil, **vars)
+        [self, term, vars]
+      end
+      alias_method DEFAULT[:meilisearch_search_method], :pagy_meilisearch
+    end
+
+    # Additions for the Pagy class
+    module Pagy
+      # Create a Pagy object from a Meilisearch results
+      def new_from_meilisearch(results, vars = {})
+        vars[:items] = results.raw_answer['limit']
+        vars[:page]  = [results.raw_answer['offset'] / vars[:items], 1].max
+        vars[:count] = results.raw_answer['nbHits']
+        new(vars)
+      end
+    end
+
+    # Add specialized backend methods to paginate Meilisearch results
+    module Backend
+      private
+
+      # Return Pagy object and results
+      def pagy_meilisearch(pagy_search_args, vars = {})
+        model, term, options = pagy_search_args
+        vars                 = pagy_meilisearch_get_vars(nil, vars)
+        options[:limit]      = vars[:items]
+        options[:offset]     = (vars[:page] - 1) * vars[:items]
+        results              = model.search(term, **options)
+        vars[:count]         = results.raw_answer['nbHits']
+        pagy                 = ::Pagy.new(vars)
+        # with :last_page overflow we need to re-run the method in order to get the hits
+        return pagy_meilisearch(pagy_search_args, vars.merge(page: pagy.page)) \
+               if defined?(::Pagy::OverflowExtra) && pagy.overflow? && pagy.vars[:overflow] == :last_page
+
+        [pagy, results]
+      end
+
+      # Sub-method called only by #pagy_meilisearch: here for easy customization of variables by overriding.
+      # The _collection argument is not available when the method is called.
+      def pagy_meilisearch_get_vars(_collection, vars)
+        pagy_set_items_from_params(vars) if defined?(ItemsExtra)
+        vars[:items] ||= DEFAULT[:items]
+        vars[:page]  ||= (params[vars[:page_param] || DEFAULT[:page_param]] || 1).to_i
+        vars
+      end
+    end
+  end
+  Meilisearch = MeilisearchExtra::Meilisearch
+  extend MeilisearchExtra::Pagy
+  Backend.prepend MeilisearchExtra::Backend
+end

data/lib/pagy/extras/metadata.rb

@@ -1,37 +1,38 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/metadata
-# encoding: utf-8
 # frozen_string_literal: true
 
-class Pagy
-  # Add a specialized backend method for pagination metadata
-  module Backend ; private
+require 'pagy/url_helpers'
 
-    METADATA = [ :scaffold_url, :first_url, :prev_url, :page_url, :next_url, :last_url,
-                 :count, :page, :items, :vars, :pages, :last, :from, :to, :prev, :next, :series ]
-    METADATA << :sequels if VARS.key?(:steps)  # :steps gets defined along with the #sequels method
+class Pagy # :nodoc:
+  DEFAULT[:metadata] = %i[ scaffold_url first_url prev_url page_url next_url last_url
+                           count page items vars pages last in from to prev next series ]
 
-    VARS[:metadata] = METADATA.dup
+  # Add a specialized backend method for pagination metadata
+  module MetadataExtra
+    private
 
-    include Helpers
+    include UrlHelpers
 
-    def pagy_metadata(pagy, url=false)
-      names = pagy.vars[:metadata]
-      (unknown = names - METADATA).empty? or raise(VariableError.new(pagy), "unknown metadata #{unknown.inspect}")
-      scaffold_url = pagy_url_for(PAGE_PLACEHOLDER, pagy, url)
-      metadata = {}
-      names.each do |key|
-        metadata[key] = case key
-                        when :scaffold_url ; scaffold_url
-                        when :first_url    ; scaffold_url.sub(PAGE_PLACEHOLDER, 1.to_s)
-                        when :prev_url     ; scaffold_url.sub(PAGE_PLACEHOLDER, pagy.prev.to_s)
-                        when :page_url     ; scaffold_url.sub(PAGE_PLACEHOLDER, pagy.page.to_s)
-                        when :next_url     ; scaffold_url.sub(PAGE_PLACEHOLDER, pagy.next.to_s)
-                        when :last_url     ; scaffold_url.sub(PAGE_PLACEHOLDER, pagy.last.to_s)
-                        else pagy.send(key)
-                        end
+    # Return the metadata hash
+    def pagy_metadata(pagy, absolute: nil)
+      scaffold_url = pagy_url_for(pagy, PAGE_PLACEHOLDER, absolute: absolute)
+      {}.tap do |metadata|
+        keys = defined?(Calendar) && pagy.is_a?(Calendar) ? pagy.vars[:metadata] - %i[count items] : pagy.vars[:metadata]
+        keys.each do |key|
+          metadata[key] = case key
+                          when :scaffold_url then scaffold_url
+                          when :first_url    then scaffold_url.sub(PAGE_PLACEHOLDER, 1.to_s)
+                          when :prev_url     then scaffold_url.sub(PAGE_PLACEHOLDER, pagy.prev.to_s)
+                          when :page_url     then scaffold_url.sub(PAGE_PLACEHOLDER, pagy.page.to_s)
+                          when :next_url     then scaffold_url.sub(PAGE_PLACEHOLDER, pagy.next.to_s)
+                          when :last_url     then scaffold_url.sub(PAGE_PLACEHOLDER, pagy.last.to_s)
+                          else pagy.send(key)
+                          end
+        rescue NoMethodError
+          raise VariableError.new(pagy, :metadata, 'to contain known keys', key)
+        end
       end
-      metadata
     end
-
   end
+  Backend.prepend MetadataExtra
 end

data/lib/pagy/extras/navs.rb

@@ -1,38 +1,63 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/navs
-# encoding: utf-8
 # frozen_string_literal: true
 
-require 'pagy/extras/shared'
-
-class Pagy
-  module Frontend
-
-    # Javascript pagination: it returns a nav and a JSON tag used by the Pagy.nav javascript
-    def pagy_nav_js(pagy, id=pagy_id)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
-      tags = { 'before' => p_prev ? %(<span class="page prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</span> )
-                                  : %(<span class="page prev disabled">#{pagy_t('pagy.nav.prev')}</span> ),
-               'link'   => %(<span class="page">#{link.call(PAGE_PLACEHOLDER)}</span> ),
-               'active' => %(<span class="page active">#{pagy.page}</span> ),
-               'gap'    => %(<span class="page gap">#{pagy_t('pagy.nav.gap')}</span> ),
-               'after'  => p_next ? %(<span class="page next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</span>)
-                                  : %(<span class="page next disabled">#{pagy_t('pagy.nav.next')}</span>) }
-      %(<nav id="#{id}" class="pagy-nav-js pagination" role="navigation" aria-label="pager"></nav>#{pagy_json_tag(:nav, id, tags, pagy.sequels, defined?(TRIM) && pagy.vars[:page_param])})
+require 'pagy/extras/frontend_helpers'
+
+class Pagy # :nodoc:
+  # Frontend modules are specially optimized for performance.
+  # The resulting code may not look very elegant, but produces the best benchmarks
+  module NavsExtra
+    # Javascript pagination: it returns a nav and a JSON tag used by the pagy.js file
+    def pagy_nav_js(pagy, pagy_id: nil, link_extra: '', **vars)
+      sequels = pagy.sequels(**vars)
+      p_id = %( id="#{pagy_id}") if pagy_id
+      link = pagy_link_proc(pagy, link_extra: link_extra)
+      tags = { 'before' => pagy_nav_prev_html(pagy, link),
+               'link'   => %(<span class="page">#{link.call(PAGE_PLACEHOLDER, LABEL_PLACEHOLDER)}</span> ),
+               'active' => %(<span class="page active">#{LABEL_PLACEHOLDER}</span> ),
+               'gap'    => %(<span class="page gap">#{pagy_t 'pagy.nav.gap'}</span> ),
+               'after'  => pagy_nav_next_html(pagy, link) }
+
+      %(<nav#{p_id} class="#{'pagy-rjs ' if sequels.size > 1}pagy-nav-js pagination" aria-label="pager" #{
+        pagy_json_attr(pagy, :nav, tags, sequels, pagy.label_sequels(sequels))}></nav>)
     end
 
-    # Javascript combo pagination: it returns a nav and a JSON tag used by the Pagy.combo_nav javascript
-    def pagy_combo_nav_js(pagy, id=pagy_id)
-      link, p_prev, p_next, p_page, p_pages = pagy_link_proc(pagy), pagy.prev, pagy.next, pagy.page, pagy.pages
-
-      html = EMPTY + %(<nav id="#{id}" class="pagy-combo-nav-js pagination" role="navigation" aria-label="pager">)
-      html << (p_prev ? %(<span class="page prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</span> )
-                      : %(<span class="page prev disabled">#{pagy_t('pagy.nav.prev')}</span> ))
-      input = %(<input type="number" min="1" max="#{p_pages}" value="#{p_page}" style="padding: 0; text-align: center; width: #{p_pages.to_s.length+1}rem;">)
-      html << %(<span class="pagy-combo-input" style="margin: 0 0.6rem;">#{pagy_t('pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages)}</span> )
-      html << (p_next ? %(<span class="page next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</span>)
-                      : %(<span class="page next disabled">#{pagy_t('pagy.nav.next')}</span>))
-      html << %(</nav>#{pagy_json_tag(:combo_nav, id, p_page, pagy_marked_link(link), defined?(TRIM) && pagy.vars[:page_param])})
+    # Javascript combo pagination: it returns a nav and a JSON tag used by the pagy.js file
+    def pagy_combo_nav_js(pagy, pagy_id: nil, link_extra: '')
+      p_id    = %( id="#{pagy_id}") if pagy_id
+      link    = pagy_link_proc(pagy, link_extra: link_extra)
+      p_page  = pagy.page
+      p_pages = pagy.pages
+      input   = %(<input type="number" min="1" max="#{p_pages}" value="#{
+                    p_page}" style="padding: 0; text-align: center; width: #{p_pages.to_s.length + 1}rem;">)
+
+      %(<nav#{p_id} class="pagy-combo-nav-js pagination" aria-label="pager" #{
+          pagy_json_attr pagy, :combo, pagy_marked_link(link)}>#{
+          pagy_nav_prev_html pagy, link
+        }<span class="pagy-combo-input" style="margin: 0 0.6rem;">#{
+          pagy_t 'pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages
+        }</span> #{
+          pagy_nav_next_html pagy, link
+        }</nav>)
     end
 
+    private
+
+    def pagy_nav_prev_html(pagy, link)
+      if (p_prev = pagy.prev)
+        %(<span class="page prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</span> )
+      else
+        %(<span class="page prev disabled">#{pagy_t 'pagy.nav.prev'}</span> )
+      end
+    end
+
+    def pagy_nav_next_html(pagy, link)
+      if (p_next = pagy.next)
+        %(<span class="page next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</span>)
+      else
+        %(<span class="page next disabled">#{pagy_t 'pagy.nav.next'}</span>)
+      end
+    end
   end
+  Frontend.prepend NavsExtra
 end

data/lib/pagy/extras/overflow.rb

@@ -1,73 +1,78 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/overflow
-# encoding: utf-8
 # frozen_string_literal: true
 
-class Pagy
+class Pagy # :nodoc:
+  DEFAULT[:overflow] = :empty_page
 
-  OVERFLOW = true
-
-  VARS[:overflow] = :empty_page
-
-  def overflow?; @overflow end
+  # Handles OverflowError exceptions for different classes with different options
+  module OverflowExtra
+    # Support for Pagy class
+    module Pagy
+      # Is the requested page overflowing?
+      def overflow?
+        @overflow
+      end
 
-  alias_method :initialize_without_overflow, :initialize
-  def initialize_with_overflow(vars)
-    @overflow ||= false                         # don't override if :last_page re-run the method after an overflow
-    initialize_without_overflow(vars)
-  rescue OverflowError
-    @overflow = true                            # add the overflow flag
-    case @vars[:overflow]
-    when :exception
-      raise                                     # same as without the extra
-    when :last_page
-      initial_page = @vars[:page]               # save the very initial page (even after re-run)
-      initialize(vars.merge!(page: @last))      # re-run with the last page
-      @vars[:page] = initial_page               # restore the inital page
-    when :empty_page
-      @offset = @items = @from = @to = 0        # vars relative to the actual page
-      @prev = @last                             # prev relative to the actual page
-      extend(Series)                            # special series for :empty_page
-    else
-      raise VariableError.new(self), "expected :overflow variable in [:last_page, :empty_page, :exception]; got #{@vars[:overflow].inspect}"
-    end
-  end
-  alias_method :initialize, :initialize_with_overflow
+      # Add rescue clause for different behaviors
+      def initialize(vars)
+        @overflow ||= false                            # still true if :last_page re-run the method after an overflow
+        super
+      rescue OverflowError
+        @overflow = true                               # add the overflow flag
+        case @vars[:overflow]
+        when :exception
+          raise                                        # same as without the extra
+        when :last_page
+          requested_page = @vars[:page]                # save the requested page (even after re-run)
+          initialize vars.merge!(page: @last)          # re-run with the last page
+          @vars[:page] = requested_page                # restore the requested page
+        when :empty_page
+          @offset = @items = @from = @to = 0           # vars relative to the actual page
+          if defined?(Calendar) && is_a?(Calendar)     # only for Calendar instances
+            edge = @order == :asc ? @final : @initial  # get the edge of the overflow side (neat, but any time would do)
+            @from = @to = edge                         # set both to the edge utc time (a >=&&< query will get no records)
+          end
+          @prev = @last                                # prev relative to the actual page
+          extend Series                                # special series for :empty_page
+        else
+          raise VariableError.new(self, :overflow, 'to be in [:last_page, :empty_page, :exception]', @vars[:overflow])
+        end
+      end
 
-  module Series
-    def series(size=@vars[:size])
-      @page = @last                               # series for last page
-      super(size).tap do |s|                      # call original series
-        s[s.index(@page.to_s)] = @page            # string to integer (i.e. no current page)
-        @page = @vars[:page]                      # restore the actual page
+      # Special series for empty page
+      module Series
+        def series(*)
+          @page = @last                                # series for last page
+          super.tap do |s|                             # call original series
+            s[s.index(@page.to_s)] = @page             # string to integer (i.e. no current page)
+            @page = @vars[:page]                       # restore the actual page
+          end
+        end
       end
     end
-  end
 
-
-  # support for Pagy::Countless
-  if defined?(Pagy::Countless)
-    class Countless
-
-      alias_method :finalize_without_overflow, :finalize
-      def finalize_with_overflow(items)
+    # Support for Pagy::Countless class
+    module Countless
+      # Add rescue clause for different behaviors
+      def finalize(items)
         @overflow = false
-        finalize_without_overflow(items)
+        super
       rescue OverflowError
-        @overflow = true                            # add the overflow flag
+        @overflow = true                               # add the overflow flag
         case @vars[:overflow]
         when :exception
-          raise                                     # same as without the extra
+          raise                                        # same as without the extra
         when :empty_page
-          @offset = @items = @from = @to = 0        # vars relative to the actual page
-          @vars[:size] = []                         # no page in the series
+          @offset = @items = @from = @to = 0           # vars relative to the actual page
+          @vars[:size] = []                            # no page in the series
           self
         else
-          raise VariableError.new(self), "expected :overflow variable in [:empty_page, :exception]; got #{@vars[:overflow].inspect}"
+          raise VariableError.new(self, :overflow, 'to be in [:empty_page, :exception]', @vars[:overflow])
         end
       end
-      alias_method :finalize, :finalize_with_overflow
-
     end
   end
-
+  prepend OverflowExtra::Pagy
+  Calendar.prepend OverflowExtra::Pagy if defined?(Calendar)
+  Countless.prepend OverflowExtra::Countless if defined?(Countless)
 end