pagy 3.8.2 → 9.4.0

data/lib/pagy/extras/array.rb

@@ -1,23 +1,19 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/array
-# encoding: utf-8
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/array
 # frozen_string_literal: true
 
-class Pagy
-  # Add specialized backend methods to paginate array collections
-  module Backend ; private
+class Pagy # :nodoc:
+  # Paginate arrays efficiently, avoiding expensive array-wrapping and without overriding
+  module ArrayExtra
+    private
 
-    # Return Pagy object and items
-    def pagy_array(array, vars={})
-      pagy = Pagy.new(pagy_array_get_vars(array, vars))
-      return pagy, array[pagy.offset, pagy.items]
-    end
-
-    # Sub-method called only by #pagy_array: here for easy customization of variables by overriding
-    def pagy_array_get_vars(array, vars)
+    # Return Pagy object and paginated items
+    def pagy_array(array, **vars)
+      vars[:limit] ||= pagy_get_limit(vars)
+      vars[:page]  ||= pagy_get_page(vars)
       vars[:count] ||= array.size
-      vars[:page]  ||= params[ vars[:page_param] || VARS[:page_param] ]
-      vars
+      pagy = Pagy.new(**vars)
+      [pagy, array[pagy.offset, pagy.limit]]
     end
-
   end
+  Backend.prepend ArrayExtra
 end

data/lib/pagy/extras/bootstrap.rb

@@ -1,55 +1,97 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/bootstrap
-# encoding: utf-8
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/bootstrap
 # frozen_string_literal: true
 
-require 'pagy/extras/shared'
-
-class Pagy
-  module Frontend
+require_relative 'js_tools'
 
+class Pagy # :nodoc:
+  # Frontend modules are specially optimized for performance.
+  # The resulting code may not look very elegant, but produces the best benchmarks
+  module BootstrapExtra
     # Pagination for bootstrap: it returns the html with the series of links to the pages
-    def pagy_bootstrap_nav(pagy)
-      link, p_prev, p_next = pagy_link_proc(pagy, 'class="page-link"'), pagy.prev, pagy.next
-
-      html = EMPTY + (p_prev ? %(<li class="page-item prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</li>)
-                             : %(<li class="page-item prev disabled"><a href="#" class="page-link">#{pagy_t('pagy.nav.prev')}</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="page-item">#{link.call item}</li>)                                                               # page link
-                elsif item.is_a?(String) ; %(<li class="page-item active">#{link.call item}</li>)                                                        # active page
-                elsif item == :gap       ; %(<li class="page-item gap disabled"><a href="#" class="page-link">#{pagy_t('pagy.nav.gap')}</a></li>) # page gap
+    def pagy_bootstrap_nav(pagy, id: nil, classes: 'pagination', aria_label: nil, **vars)
+      id = %( id="#{id}") if id
+      a  = pagy_anchor(pagy, **vars)
+
+      html = %(<nav#{id} class="pagy-bootstrap nav" #{nav_aria_label(pagy, aria_label:)}><ul class="#{classes}">#{
+                 bootstrap_prev_html(pagy, a)})
+      pagy.series(**vars).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+        html << case item
+                when Integer
+                  %(<li class="page-item">#{a.(item, classes: 'page-link')}</li>)
+                when String
+                  %(<li class="page-item active"><a role="link" class="page-link" aria-current="page" aria-disabled="true">#{
+                      pagy.label_for(item)}</a></li>)
+                when :gap
+                  %(<li class="page-item gap disabled"><a role="link" class="page-link" aria-disabled="true">#{
+                      pagy_t('pagy.gap')}</a></li>)
+                else raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
                 end
       end
-      html << (p_next ? %(<li class="page-item next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</li>)
-                      : %(<li class="page-item next disabled"><a href="#" class="page-link">#{pagy_t('pagy.nav.next')}</a></li>))
-      %(<nav class="pagy-bootstrap-nav" role="navigation" aria-label="pager"><ul class="pagination">#{html}</ul></nav>)
+      html << %(#{bootstrap_next_html(pagy, a)}</ul></nav>)
     end
 
-    # Javascript pagination for bootstrap: it returns a nav and a JSON tag used by the Pagy.nav javascript
-    def pagy_bootstrap_nav_js(pagy, id=pagy_id)
-      link, p_prev, p_next = pagy_link_proc(pagy, 'class="page-link"'), pagy.prev, pagy.next
-      tags = { 'before' => p_prev ? %(<ul class="pagination"><li class="page-item prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</li>)
-                                  : %(<ul class="pagination"><li class="page-item prev disabled"><a href="#" class="page-link">#{pagy_t('pagy.nav.prev')}</a></li>),
-               'link'   => %(<li class="page-item">#{mark = link.call(PAGE_PLACEHOLDER)}</li>),
-               'active' => %(<li class="page-item active">#{mark}</li>),
-               'gap'    => %(<li class="page-item gap disabled"><a href="#" class="page-link">#{pagy_t('pagy.nav.gap')}</a></li>),
-               'after'  => p_next ? %(<li class="page-item next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</li></ul>)
-                                  : %(<li class="page-item next disabled"><a href="#" class="page-link">#{pagy_t('pagy.nav.next')}</a></li></ul>) }
-      %(<nav id="#{id}" class="pagy-bootstrap-nav-js" role="navigation" aria-label="pager"></nav>#{pagy_json_tag(:nav, id, tags, pagy.sequels, defined?(TRIM) && pagy.vars[:page_param])})
+    # Javascript pagination for bootstrap: it returns a nav with a data-pagy attribute used by the pagy.js file
+    def pagy_bootstrap_nav_js(pagy, id: nil, classes: 'pagination', aria_label: nil, **vars)
+      sequels = pagy.sequels(**vars)
+      id      = %( id="#{id}") if id
+      a       = pagy_anchor(pagy, **vars)
+      tokens  = { 'before'  => %(<ul class="#{classes}">#{bootstrap_prev_html(pagy, a)}),
+                  'a'       => %(<li class="page-item">#{a.(PAGE_TOKEN, LABEL_TOKEN, classes: 'page-link')}</li>),
+                  'current' => %(<li class="page-item active"><a role="link" class="page-link" ) +
+                               %(aria-current="page" aria-disabled="true">#{LABEL_TOKEN}</a></li>),
+                  'gap'     => %(<li class="page-item gap disabled"><a role="link" class="page-link" aria-disabled="true">#{
+                                   pagy_t('pagy.gap')}</a></li>),
+                  'after'   => %(#{bootstrap_next_html pagy, a}</ul>) }
+
+      %(<nav#{id} class="#{'pagy-rjs ' if sequels.size > 1}pagy-bootstrap nav-js" #{
+          nav_aria_label(pagy, aria_label:)} #{
+          pagy_data(pagy, :nav, tokens, sequels, pagy.label_sequels(sequels))
+        }></nav>)
     end
 
-    # Javascript combo pagination for bootstrap: it returns a nav and a JSON tag used by the Pagy.combo_nav javascript
-    def pagy_bootstrap_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 = %(<nav id="#{id}" class="pagy-bootstrap-combo-nav-js pagination" role="navigation" aria-label="pager">) + %(<div class="btn-group" role="group">)
-      html << (p_prev ? link.call(p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous" class="prev btn btn-primary"')
-                      : %(<a class="prev btn btn-primary disabled" href="#">#{pagy_t('pagy.nav.prev')}</a>))
-      input = %(<input type="number" min="1" max="#{p_pages}" value="#{p_page}" class="text-primary" style="padding: 0; border: none; text-align: center; width: #{p_pages.to_s.length+1}rem;">)
-      html << %(<div class="pagy-combo-input btn btn-primary disabled" style="white-space: nowrap;">#{pagy_t('pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages)}</div>)
-      html << (p_next ? link.call(p_next, pagy_t('pagy.nav.next'), 'aria-label="next" class="next btn btn-primary"')
-                      : %(<a class="next btn btn-primary disabled" href="#">#{pagy_t('pagy.nav.next')}</a>))
-      html << %(</div></nav>#{pagy_json_tag(:combo_nav, id, p_page, pagy_marked_link(link), defined?(TRIM) && pagy.vars[:page_param])})
+    # Javascript combo pagination for bootstrap: it returns a nav with a data-pagy attribute used by the pagy.js file
+    def pagy_bootstrap_combo_nav_js(pagy, id: nil, classes: 'pagination', aria_label: nil, **vars)
+      id    = %( id="#{id}") if id
+      a     = pagy_anchor(pagy, **vars)
+      pages = pagy.pages
+
+      page_input = %(<input name="page" type="number" min="1" max="#{pages}" value="#{pagy.page}" aria-current="page" ) <<
+                   %(style="text-align: center; width: #{pages.to_s.length + 1}rem; padding: 0; ) <<
+                   %(border: none; display: inline-block;" class="page-link active">#{JSTools::A_TAG})
+
+      %(<nav#{id} class="pagy-bootstrap combo-nav-js" #{
+          nav_aria_label(pagy, aria_label:)} #{
+          pagy_data(pagy, :combo, pagy_url_for(pagy, PAGE_TOKEN, **vars))
+        }><ul class="#{classes}">#{
+          bootstrap_prev_html(pagy, a)
+        }<li class="page-item pagy-bootstrap"><label class="page-link">#{
+          pagy_t('pagy.combo_nav_js', page_input:, pages:)
+        }</label></li>#{
+          bootstrap_next_html(pagy, a)
+        }</ul></nav>)
     end
 
+    private
+
+    def bootstrap_prev_html(pagy, a)
+      if (p_prev = pagy.prev)
+        %(<li class="page-item prev">#{
+            a.(p_prev, pagy_t('pagy.prev'), classes: 'page-link', aria_label: pagy_t('pagy.aria_label.prev'))}</li>)
+      else
+        %(<li class="page-item prev disabled"><a role="link" class="page-link" aria-disabled="true" aria-label="#{
+            pagy_t('pagy.aria_label.prev')}">#{pagy_t('pagy.prev')}</a></li>)
+      end
+    end
+
+    def bootstrap_next_html(pagy, a)
+      if (p_next = pagy.next)
+        %(<li class="page-item next">#{
+            a.(p_next, pagy_t('pagy.next'), classes: 'page-link', aria_label: pagy_t('pagy.aria_label.next'))}</li>)
+      else
+        %(<li class="page-item next disabled"><a role="link" class="page-link" aria-disabled="true" aria-label="#{
+            pagy_t('pagy.aria_label.next')}">#{pagy_t('pagy.next')}</a></li>)
+      end
+    end
   end
+  Frontend.prepend BootstrapExtra
 end

data/lib/pagy/extras/bulma.rb

@@ -1,60 +1,93 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/bulma
-# encoding: utf-8
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/bulma
 # frozen_string_literal: true
 
-require 'pagy/extras/shared'
+require_relative 'js_tools'
 
-class Pagy
-  module Frontend
+class Pagy # :nodoc:
+  # Frontend modules are specially optimized for performance.
+  # The resulting code may not look very elegant, but produces the best benchmarks
+  module BulmaExtra
+    # Pagination for bulma: it returns the html with the series of links to the pages
+    def pagy_bulma_nav(pagy, id: nil, classes: 'pagy-bulma nav pagination is-centered',
+                       aria_label: nil, **vars)
+      id = %( id="#{id}") if id
+      a  = pagy_anchor(pagy, **vars)
 
-    # Pagination for Bulma: it returns the html with the series of links to the pages
-    def pagy_bulma_nav(pagy)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
-
-      html = (p_prev ? link.call(p_prev, pagy_t('pagy.nav.prev'), 'class="pagination-previous" aria-label="previous page"')
-                     : %(<a class="pagination-previous" disabled>#{pagy_t('pagy.nav.prev')}</a>)) \
-           + (p_next ? link.call(p_next, pagy_t('pagy.nav.next'), 'class="pagination-next" aria-label="next page"')
-                     : %(<a class="pagination-next" disabled>#{pagy_t('pagy.nav.next')}</a>))
-      html << '<ul class="pagination-list">'
-      pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
-        html << if    item.is_a?(Integer); %(<li>#{link.call item, item, %(class="pagination-link" aria-label="goto page #{item}") }</li>)                           # page link
-                elsif item.is_a?(String) ; %(<li>#{link.call item, item, %(class="pagination-link is-current" aria-label="page #{item}" aria-current="page")}</li>)  # active page
-                elsif item == :gap       ; %(<li><span class="pagination-ellipsis">#{pagy_t('pagy.nav.gap')}</span></li>)                                            # page gap
+      html = %(<nav#{id} class="#{classes}" #{nav_aria_label(pagy, aria_label:)}>)
+      html << bulma_prev_next_html(pagy, a)
+      html << %(<ul class="pagination-list">)
+      pagy.series(**vars).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+        html << case item
+                when Integer
+                  %(<li>#{a.(item, pagy.label_for(item), classes: 'pagination-link')}</li>)
+                when String
+                  %(<li><a role="link" class="pagination-link is-current" aria-current="page" aria-disabled="true">#{
+                      pagy.label_for(item)}</a></li>)
+                when :gap
+                  %(<li><span class="pagination-ellipsis">#{pagy_t 'pagy.gap'}</span></li>)
+                else raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
                 end
       end
-      html << '</ul>'
-      %(<nav class="pagy-bulma-nav pagination is-centered" role="navigation" aria-label="pagination">#{html}</nav>)
+      html << %(</ul></nav>)
     end
 
-    # Javascript pagination for bulma: it returns a nav and a JSON tag used by the Pagy.nav javascript
-    def pagy_bulma_nav_js(pagy, id=pagy_id)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
-      tags = { 'before' => ( (p_prev ? link.call(p_prev, pagy_t('pagy.nav.prev'), 'class="pagination-previous" aria-label="previous page"')
-                                     : %(<a class="pagination-previous" disabled>#{pagy_t('pagy.nav.prev')}</a>)) \
-                           + (p_next ? link.call(p_next, pagy_t('pagy.nav.next'), 'class="pagination-next" aria-label="next page"')
-                                     : %(<a class="pagination-next" disabled>#{pagy_t('pagy.nav.next')}</a>)) \
-                           + '<ul class="pagination-list">' ),
-               'link'   => %(<li>#{link.call(PAGE_PLACEHOLDER, PAGE_PLACEHOLDER, %(class="pagination-link" aria-label="goto page #{PAGE_PLACEHOLDER}"))}</li>),
-               'active' => %(<li>#{link.call(PAGE_PLACEHOLDER, PAGE_PLACEHOLDER, %(class="pagination-link is-current" aria-current="page" aria-label="page #{PAGE_PLACEHOLDER}"))}</li>),
-               'gap'    => %(<li><span class="pagination-ellipsis">#{pagy_t('pagy.nav.gap')}</span></li>),
-               'after'  => '</ul>' }
-      %(<nav id="#{id}" class="pagy-bulma-nav-js pagination is-centered" role="navigation" aria-label="pagination"></nav>#{pagy_json_tag(:nav, id, tags, pagy.sequels, defined?(TRIM) && pagy.vars[:page_param])})
+    # Javascript pagination for bulma: it returns a nav with a data-pagy attribute used by the Pagy.nav javascript
+    def pagy_bulma_nav_js(pagy, id: nil, classes: 'pagy-bulma nav-js pagination is-centered',
+                          aria_label: nil, **vars)
+      sequels = pagy.sequels(**vars)
+      id      = %( id="#{id}") if id
+      a       = pagy_anchor(pagy, **vars)
+      tokens = { 'before'  => %(#{bulma_prev_next_html(pagy, a)}<ul class="pagination-list">),
+                 'a'       => %(<li>#{a.(PAGE_TOKEN, LABEL_TOKEN, classes: 'pagination-link')}</li>),
+                 'current' => %(<li><a role="link" class="pagination-link is-current" aria-current="page" aria-disabled="true">#{
+                                  LABEL_TOKEN}</a></li>),
+                 'gap'     => %(<li><span class="pagination-ellipsis">#{pagy_t 'pagy.gap'}</span></li>),
+                 'after'   => '</ul>' }
+
+      %(<nav#{id} class="#{'pagy-rjs ' if sequels.size > 1}#{classes}" #{
+          nav_aria_label(pagy, aria_label:)} #{
+          pagy_data(pagy, :nav, tokens, sequels, pagy.label_sequels(sequels))
+        }></nav>)
     end
 
-    # Javascript combo pagination for Bulma: it returns a nav and a JSON tag used by the Pagy.combo_nav javascript
-    def pagy_bulma_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 = %(<nav id="#{id}" class="pagy-bulma-combo-nav-js" role="navigation" aria-label="pagination">) \
-           + %(<div class="field is-grouped is-grouped-centered" role="group">)
-      html << (p_prev ? %(<p class="control">#{link.call(p_prev, pagy_t('pagy.nav.prev'), 'class="button" aria-label="previous page"')}</p>)
-                      : %(<p class="control"><a class="button" disabled>#{pagy_t('pagy.nav.prev')}</a></p>))
-      input = %(<input class="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; margin:0 0.3rem;">)
-      html << %(<div class="pagy-combo-input control level is-mobile">#{pagy_t('pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages)}</div>)
-      html << (p_next ? %(<p class="control">#{link.call(p_next, pagy_t('pagy.nav.next'), 'class="button" aria-label="next page"')}</p>)
-                      : %(<p class="control"><a class="button" disabled>#{pagy_t('pagy.nav.next')}</a></p>))
-      html << %(</div></nav>#{pagy_json_tag(:combo_nav, id, p_page, pagy_marked_link(link), defined?(TRIM) && pagy.vars[:page_param])})
+    # Javascript combo pagination for bulma: it returns a nav with a data-pagy attribute used by the pagy.js file
+    def pagy_bulma_combo_nav_js(pagy, id: nil, classes: 'pagy-bulma combo-nav-js pagination is-centered',
+                                aria_label: nil, **vars)
+      id    = %( id="#{id}") if id
+      a     = pagy_anchor(pagy, **vars)
+      pages = pagy.pages
+
+      page_input = %(<input name="page" type="number" min="1" max="#{pages}" value="#{pagy.page}" aria-current="page") <<
+                   %(style="text-align: center; width: #{pages.to_s.length + 1}rem; height: 1.7rem; margin:0 0.3rem; ) <<
+                   %(border: none; border-radius: 4px; padding: 0; font-size: 1.1rem; color: white; ) <<
+                   %(background-color: #485fc7;">#{JSTools::A_TAG})
+
+      %(<nav#{id} class="#{classes}" #{
+          nav_aria_label(pagy, aria_label:)} #{
+          pagy_data(pagy, :combo, pagy_url_for(pagy, PAGE_TOKEN, **vars))
+        }>#{
+          bulma_prev_next_html(pagy, a)
+        }<ul class="pagination-list"><li class="pagination-link"><label>#{
+           pagy_t('pagy.combo_nav_js', page_input:, pages:)
+        }</label></li></ul></nav>)
     end
 
+    private
+
+    def bulma_prev_next_html(pagy, a)
+      html = if (p_prev = pagy.prev)
+               a.(p_prev, pagy_t('pagy.prev'), classes: 'pagination-previous', aria_label: pagy_t('pagy.aria_label.prev'))
+             else
+               %(<a role="link" class="pagination-previous" disabled aria-disabled="true" aria-label="#{
+                   pagy_t('pagy.aria_label.prev')}">#{pagy_t 'pagy.prev'}</a>)
+             end
+      html << if (p_next = pagy.next)
+                a.(p_next, pagy_t('pagy.next'), classes: 'pagination-next', aria_label: pagy_t('pagy.aria_label.next'))
+              else
+                %(<a role="link" class="pagination-next" disabled aria-disabled="true" aria-label="#{
+                    pagy_t('pagy.aria_label.next')}">#{pagy_t('pagy.next')}</a>)
+              end
+    end
   end
+  Frontend.prepend BulmaExtra
 end

data/lib/pagy/extras/calendar.rb

@@ -0,0 +1,79 @@
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/calendar
+# frozen_string_literal: true
+
+require_relative '../calendar'
+
+class Pagy # :nodoc:
+  # Add pagination filtering by calendar unit (:year, :quarter, :month, :week, :day) to the regular pagination
+  module CalendarExtra
+    # Additions for the Backend module
+    module BackendAddOn
+      CONF_KEYS = (Calendar::UNITS + %i[pagy active]).freeze
+
+      private
+
+      # Take a collection and a conf Hash with keys in CONF_KEYS and return an array with 3 items: [calendar, pagy, results]
+      def pagy_calendar(collection, conf)
+        raise ArgumentError, "keys must be in #{CONF_KEYS.inspect}" \
+              unless conf.is_a?(Hash) && (conf.keys - CONF_KEYS).empty?
+
+        conf[:pagy] ||= {}
+        unless conf.key?(:active) && !conf[:active]
+          calendar, from, to = Calendar.send(:init, conf, pagy_calendar_period(collection), params) do |unit, period|
+                                 pagy_calendar_counts(collection, unit, *period) if respond_to?(:pagy_calendar_counts)
+                               end
+          collection = pagy_calendar_filter(collection, from, to)
+        end
+        pagy, results = send(conf[:pagy][:backend] || :pagy, collection, **conf[:pagy])  # use backend: :pagy when omitted
+        [calendar, pagy, results]
+      end
+
+      # This method must be implemented by the application
+      def pagy_calendar_period(*)
+        raise NoMethodError, 'the pagy_calendar_period method must be implemented by the application ' \
+                             '(see https://ddnexus.github.io/pagy/docs/extras/calendar/#pagy-calendar-period-collection)'
+      end
+
+      # This method must be implemented by the application
+      def pagy_calendar_filter(*)
+        raise NoMethodError, 'the pagy_calendar_filter method must be implemented by the application ' \
+                             '(see https://ddnexus.github.io/pagy/docs/extras/calendar/#pagy-calendar-filter-collection-from-to)'
+      end
+    end
+
+    # Override the pagy_anchor
+    module FrontendOverride
+      # Consider the vars[:counts]
+      def pagy_anchor(pagy, anchor_string: nil)
+        return super unless (counts = pagy.vars[:counts])
+
+        anchor_string &&= %( #{anchor_string})
+        left, right = %(<a#{anchor_string} href="#{pagy_url_for(pagy, PAGE_TOKEN)}").split(PAGE_TOKEN, 2)
+        # lambda used by all the helpers
+        lambda do |page, text = pagy.label_for(page), classes: nil, aria_label: nil|
+          count = counts[page - 1]
+          if count.zero?
+            classes  = "#{classes && (classes + ' ')}empty-page"
+            info_key = 'pagy.info.no_items'
+          else
+            info_key = 'pagy.info.single_page'
+          end
+          title      = %( title="#{pagy_t(info_key, item_name: pagy_t('pagy.item_name', count:), count:)}")
+          classes    = %( class="#{classes}") if classes
+          aria_label = %( aria-label="#{aria_label}") if aria_label
+          %(#{left}#{page}#{right}#{title}#{classes}#{aria_label}>#{text}</a>)
+        end
+      end
+    end
+
+    # Additions for the Frontend module
+    module UrlHelperAddOn
+      # Return the url for the calendar page at time
+      def pagy_calendar_url_at(calendar, time, **opts)
+        pagy_url_for(calendar.send(:calendar_at, time, **opts), 1, **opts)
+      end
+    end
+  end
+  Backend.prepend CalendarExtra::BackendAddOn, CalendarExtra::UrlHelperAddOn
+  Frontend.prepend CalendarExtra::UrlHelperAddOn, CalendarExtra::FrontendOverride
+end

data/lib/pagy/extras/countless.rb

@@ -1,37 +1,32 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/countless
-# encoding: utf-8
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/countless
 # frozen_string_literal: true
 
-require 'pagy/countless'
+require_relative '../countless'
 
-class Pagy
+class Pagy # :nodoc:
+  DEFAULT[:countless_minimal] = false
 
-  # used by the items extra
-  COUNTLESS = true
+  # Paginate without the need of any count, saving one query per rendering
+  module CountlessExtra
+    private
 
-  module Backend ; private         # the whole module is private so no problem with including it in a controller
-
-    # Return Pagy object and items
-    def pagy_countless(collection, vars={})
-      pagy = Pagy::Countless.new(pagy_countless_get_vars(collection, vars))
-      return pagy, pagy_countless_get_items(collection, pagy)
-    end
-
-    # Sub-method called only by #pagy_countless: here for easy customization of variables by overriding
-    def pagy_countless_get_vars(_collection, vars)
-      vars[:page] ||= params[ vars[:page_param] || VARS[:page_param] ]
-      vars
+    # Return Pagy object and records
+    def pagy_countless(collection, **vars)
+      vars[:limit] ||= pagy_get_limit(vars)
+      vars[:page]  ||= pagy_get_page(vars)
+      pagy = Countless.new(**vars)
+      [pagy, pagy_countless_get_items(collection, pagy)]
     end
 
     # Sub-method called only by #pagy_countless: here for easy customization of record-extraction by overriding
+    # You may need to override this method for collections without offset|limit
     def pagy_countless_get_items(collection, pagy)
-      # This should work with ActiveRecord, Sequel, Mongoid...
-      items      = collection.offset(pagy.offset).limit(pagy.items + 1).to_a
-      items_size = items.size
-      items.pop if items_size == pagy.items + 1
-      pagy.finalize(items_size)                  # finalize may adjust pagy.items, so must be used after checking the size
-      items
-    end
+      return collection.offset(pagy.offset).limit(pagy.limit) if pagy.vars[:countless_minimal]
 
+      fetched = collection.offset(pagy.offset).limit(pagy.limit + 1).to_a # eager load limit + 1
+      pagy.finalize(fetched.size)                                         # finalize the pagy object
+      fetched[0, pagy.limit]                                              # ignore eventual extra item
+    end
   end
+  Backend.prepend CountlessExtra
 end

data/lib/pagy/extras/elasticsearch_rails.rb

@@ -1,50 +1,71 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/elasticsearch_rails
-# encoding: utf-8
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/elasticsearch_rails
 # frozen_string_literal: true
 
-require 'pagy/extras/pagy_search'
+class Pagy # :nodoc:
+  DEFAULT[:elasticsearch_rails_search]      ||= :search
+  DEFAULT[:elasticsearch_rails_pagy_search] ||= :pagy_search
 
-class Pagy
+  # Paginate ElasticsearchRails response objects
+  module ElasticsearchRailsExtra
+    module_function
 
-  # used by the items extra
-  ELASTICSEARCH_RAILS = true
-
-  # create a Pagy object from an Elasticsearch::Model::Response::Response object
-  def self.new_from_elasticsearch_rails(response, vars={})
-    vars[:items] = response.search.options[:size] || 10
-    vars[:page]  = (response.search.options[:from] || 0) / vars[:items] + 1
-    total        = response.respond_to?(:raw_response) ? response.raw_response['hits']['total'] : response.response['hits']['total']
-    vars[:count] = total.is_a?(Hash) ? total['value'] : total
-    new(vars)
-  end
+    # Get the count from different version of ElasticsearchRails
+    def total_count(response)
+      total = if response.respond_to?(:raw_response)
+                response.raw_response['hits']['total']
+              else
+                response.response['hits']['total']
+              end
+      total.is_a?(Hash) ? total['value'] : total
+    end
 
-  # Add specialized backend methods to paginate ElasticsearchRails searches
-  module Backend ; private
-
-    # Return Pagy object and items
-    def pagy_elasticsearch_rails(pagy_search_args, vars={})
-      model, search_args, _block, *called = pagy_search_args
-      vars                   = pagy_elasticsearch_rails_get_vars(nil, vars)
-      search_args[-1][:size] = vars[:items]
-      search_args[-1][:from] = vars[:items] * (vars[:page] - 1)
-      response               = model.search(*search_args)
-      total                  = response.respond_to?(:raw_response) ? response.raw_response['hits']['total'] : response.response['hits']['total']
-      vars[:count]           = total.is_a?(Hash) ? total['value'] : total
-      pagy = Pagy.new(vars)
-      # with :last_page overflow we need to re-run the method in order to get the hits
-      if defined?(OVERFLOW) && pagy.overflow? && pagy.vars[:overflow] == :last_page
-        return pagy_elasticsearch_rails(pagy_search_args, vars.merge(page: pagy.page))
+    module ModelExtension # :nodoc:
+      # Return an array used to delay the call of #search
+      # after the pagination variables are merged to the options.
+      # It also pushes to the same array an optional method call.
+      def pagy_elasticsearch_rails(query_or_payload, **options)
+        [self, query_or_payload, options].tap do |args|
+          args.define_singleton_method(:method_missing) { |*a| args += a }
+        end
       end
-      return pagy, called.empty? ? response : response.send(*called)
+      alias_method DEFAULT[:elasticsearch_rails_pagy_search], :pagy_elasticsearch_rails
     end
+    Pagy::ElasticsearchRails = ModelExtension
 
-    # Sub-method called only by #pagy_elasticsearch_rails: here for easy customization of variables by overriding
-    # the _collection argument is not available when the method is called
-    def pagy_elasticsearch_rails_get_vars(_collection, vars)
-      vars[:items] ||= VARS[:items]
-      vars[:page]  ||= (params[ vars[:page_param] || VARS[:page_param] ] || 1).to_i
-      vars
+    # Additions for the Pagy class
+    module PagyAddOn
+      # Create a Pagy object from an Elasticsearch::Model::Response::Response object
+      def new_from_elasticsearch_rails(response, **vars)
+        vars[:limit] = response.search.options[:size] || 10
+        vars[:page]  = ((response.search.options[:from] || 0) / vars[:limit]) + 1
+        vars[:count] = ElasticsearchRailsExtra.total_count(response)
+        Pagy.new(**vars)
+      end
     end
+    Pagy.extend PagyAddOn
+
+    # Add specialized backend methods to paginate ElasticsearchRails searches
+    module BackendAddOn
+      private
 
+      # Return Pagy object and records
+      def pagy_elasticsearch_rails(pagy_search_args, **vars)
+        vars[:page]  ||= pagy_get_page(vars)
+        vars[:limit] ||= pagy_get_limit(vars)
+        model, query_or_payload, options, *called = pagy_search_args
+        options[:size] = vars[:limit]
+        options[:from] = vars[:limit] * ((vars[:page] || 1) - 1)
+        response       = model.send(DEFAULT[:elasticsearch_rails_search], query_or_payload, **options)
+        vars[:count]   = ElasticsearchRailsExtra.total_count(response)
+
+        pagy = ::Pagy.new(**vars)
+        # with :last_page overflow we need to re-run the method in order to get the hits
+        return pagy_elasticsearch_rails(pagy_search_args, **vars, page: pagy.page) \
+               if defined?(::Pagy::OverflowExtra) && pagy.overflow? && pagy.vars[:overflow] == :last_page
+
+        [pagy, called.empty? ? response : response.send(*called)]
+      end
+    end
+    Backend.prepend BackendAddOn
   end
 end