pagy 3.10.0 → 5.7.3

data/lib/pagy/extras/calendar.rb

@@ -0,0 +1,66 @@
+# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/calendar
+# frozen_string_literal: true
+
+require 'pagy/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 Backend
+      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)
+        unless conf.is_a?(Hash) && (conf.keys - CONF_KEYS).empty? && conf.all? { |k, v| v.is_a?(Hash) || k == :active }
+          raise ArgumentError, "keys must be in #{CONF_KEYS.inspect} and object values must be Hashes; got #{conf.inspect}"
+        end
+
+        conf[:pagy]          = {} unless conf[:pagy]  # use default Pagy object when omitted
+        calendar, collection = pagy_setup_calendar(collection, conf) unless conf.key?(:active) && !conf[:active]
+        pagy, results        = send(conf[:pagy][:backend] || :pagy, collection, conf[:pagy])  # use backend: :pagy when omitted
+        [calendar, pagy, results]
+      end
+
+      # Setup and return the calendar objects and the filtered collection
+      def pagy_setup_calendar(collection, conf)
+        units = Calendar::UNITS & conf.keys # get the units in time length desc order
+        raise ArgumentError, 'no calendar unit found in pagy_calendar configuration' if units.empty?
+
+        page_param = conf[:pagy][:page_param] || DEFAULT[:page_param]
+        units.each do |unit|  # set all the :page_param vars for later deletion
+          unit_page_param         = :"#{unit}_#{page_param}"
+          conf[unit][:page_param] = unit_page_param
+          conf[unit][:page]       = params[unit_page_param]
+        end
+        calendar = {}
+        last_obj = nil
+        units.each_with_index do |unit, index|
+          params_to_delete    = units[(index + 1), units.size].map { |sub| conf[sub][:page_param] } + [page_param]
+          conf[unit][:params] = lambda do |params|  # delete page_param from the sub-units
+                                  params_to_delete.each { |p| params.delete(p.to_s) } # Hash#except missing from ruby 2.5 baseline
+                                  params
+                                end
+          conf[unit][:period] = last_obj&.send(:active_period) || pagy_calendar_period(collection)
+          calendar[unit]      = last_obj = Calendar.send(:create, unit, conf[unit])
+        end
+        [calendar, pagy_calendar_filter(collection, last_obj.from, last_obj.to)]
+      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/extras/calendar#pagy_calendar_periodcollection)'
+      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/extras/calendar#pagy_calendar_filtercollection-from-to)'
+      end
+    end
+  end
+  Backend.prepend CalendarExtra::Backend
+end

data/lib/pagy/extras/countless.rb

@@ -1,37 +1,37 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/countless
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'pagy/countless'
 
-class Pagy
+class Pagy # :nodoc:
+  DEFAULT[:countless_minimal] = false
 
-  # used by the items extra
-  COUNTLESS = true
-
-  module Backend ; private         # the whole module is private so no problem with including it in a controller
+  # Paginate without the need of any count, saving one query per rendering
+  module CountlessExtra
+    private
 
     # 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)
+    def pagy_countless(collection, vars = {})
+      pagy = Countless.new(pagy_countless_get_vars(collection, vars))
+      [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] ]
+      pagy_set_items_from_params(vars) if defined?(ItemsExtra)
+      vars[:page] ||= params[vars[:page_param] || DEFAULT[:page_param]]
       vars
     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.items) if pagy.vars[:countless_minimal]
 
+      fetched = collection.offset(pagy.offset).limit(pagy.items + 1).to_a # eager load items + 1
+      pagy.finalize(fetched.size)                                         # finalize the pagy object
+      fetched[0, pagy.items]                                              # ignore eventual extra item
+    end
   end
+  Backend.prepend CountlessExtra
 end

data/lib/pagy/extras/elasticsearch_rails.rb

@@ -1,50 +1,79 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/elasticsearch_rails
-# encoding: utf-8
 # frozen_string_literal: true
 
-require 'pagy/extras/pagy_search'
+class Pagy # :nodoc:
+  DEFAULT[:elasticsearch_rails_search_method] ||= :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 ElasticsearchRails # :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 Pagy::DEFAULT[:elasticsearch_rails_search_method], :pagy_elasticsearch_rails
     end
 
-    # 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 Pagy
+      # Create a Pagy object from an Elasticsearch::Model::Response::Response object
+      def new_from_elasticsearch_rails(response, vars = {})
+        vars[:items] = response.search.options[:size] || 10
+        vars[:page]  = ((response.search.options[:from] || 0) / vars[:items]) + 1
+        vars[:count] = ElasticsearchRailsExtra.total_count(response)
+        new(vars)
+      end
     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, query_or_payload,
+        options, *called = pagy_search_args
+        vars             = pagy_elasticsearch_rails_get_vars(nil, vars)
+        options[:size]   = vars[:items]
+        options[:from]   = vars[:items] * (vars[:page] - 1)
+        response         = model.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.merge(page: pagy.page)) \
+               if defined?(::Pagy::OverflowExtra) && pagy.overflow? && pagy.vars[:overflow] == :last_page
+
+        [pagy, called.empty? ? response : response.send(*called)]
+      end
+
+      # 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)
+        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
+  ElasticsearchRails = ElasticsearchRailsExtra::ElasticsearchRails
+  extend ElasticsearchRailsExtra::Pagy
+  Backend.prepend ElasticsearchRailsExtra::Backend
 end

data/lib/pagy/extras/foundation.rb

@@ -1,57 +1,90 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/foundation
-# 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 FoundationExtra
     # Pagination for Foundation: it returns the html with the series of links to the pages
-    def pagy_foundation_nav(pagy)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
-
-      html = EMPTY + (p_prev ? %(<li class="prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</li>)
-                             : %(<li class="prev disabled">#{pagy_t('pagy.nav.prev')}</li>))
-      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}</li>)                        # page link
-                elsif item.is_a?(String) ; %(<li class="current">#{item}</li>)                  # active page
-                elsif item == :gap       ; %(<li class="ellipsis gap" aria-hidden="true"></li>) # page gap
+    def pagy_foundation_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 = +%(<nav#{p_id} class="pagy-foundation-nav" aria-label="Pagination"><ul class="pagination">)
+      html << pagy_foundation_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>#{link.call item}</li>)                        # page link
+                when String  then %(<li class="current">#{pagy.label_for(item)}</li>)                  # active page
+                when :gap    then %(<li class="ellipsis gap" aria-hidden="true"></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="next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</li>)
-                      : %(<li class="next disabled">#{pagy_t('pagy.nav.next')}</li>))
-      %(<nav class="pagy-foundation-nav" role="navigation" aria-label="Pagination"><ul class="pagination">#{html}</ul></nav>)
+      html << pagy_foundation_next_html(pagy, link)
+      html << %(</ul></nav>)
     end
 
-    # Javascript pagination for foundation: it returns a nav and a JSON tag used by the Pagy.nav javascript
-    def pagy_foundation_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="prev">#{link.call(p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"')}</li>)
-                                     : %(<li class="prev disabled">#{pagy_t('pagy.nav.prev')}</li>)) ),
-               'link'   => %(<li>#{link.call(PAGE_PLACEHOLDER)}</li>),
-               'active' => %(<li class="current">#{pagy.page}</li>),
+    # Javascript pagination for foundation: it returns a nav and a JSON tag used by the pagy.js file
+    def pagy_foundation_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_foundation_prev_html pagy, link}),
+               'link'   => %(<li>#{link.call(PAGE_PLACEHOLDER, LABEL_PLACEHOLDER)}</li>),
+               'active' => %(<li class="current">#{LABEL_PLACEHOLDER}</li>),
                'gap'    => %(<li class="ellipsis gap" aria-hidden="true"></li>),
-               'after'  => ( (p_next ? %(<li class="next">#{link.call(p_next, pagy_t('pagy.nav.next'), 'aria-label="next"')}</li>)
-                                     : %(<li class="next disabled">#{pagy_t('pagy.nav.next')}</li>)) \
-                           + '</ul>' ) }
-      %(<nav id="#{id}" class="pagy-foundation-nav-js" role="navigation" aria-label="Pagination"></nav>#{pagy_json_tag(:nav, id, tags, pagy.sequels, defined?(TRIM) && pagy.vars[:page_param])})
+               'after'  => %(#{pagy_foundation_next_html pagy, link}</ul>) }
+
+      %(<nav#{p_id} class="#{'pagy-rjs ' if sequels.size > 1}pagy-foundation-nav-js" aria-label="Pagination" #{
+        pagy_json_attr(pagy, :nav, tags, sequels, pagy.label_sequels(sequels))}></nav>)
+    end
+
+    # Javascript combo pagination for Foundation: it returns a nav and a JSON tag used by the pagy.js file
+    def pagy_foundation_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 class="input-group-field cell shrink" type="number" min="1" max="#{
+                    p_pages}" value="#{p_page}" style="width: #{
+                    p_pages.to_s.length + 1}rem; padding: 0 0.3rem; margin: 0 0.3rem;">)
+
+      %(<nav#{p_id} class="pagy-foundation-combo-nav-js" aria-label="Pagination"><div class="input-group" #{
+          pagy_json_attr pagy, :combo, pagy_marked_link(link)}>#{
+          if (p_prev  = pagy.prev)
+            link.call p_prev, pagy_t('pagy.nav.prev'),
+                      'style="margin-bottom: 0" aria-label="previous" class="prev button primary"'
+          else
+            %(<a style="margin-bottom: 0" class="prev button primary disabled" href="#">#{pagy_t 'pagy.nav.prev'}</a>)
+          end
+        }<span class="input-group-label">#{pagy_t 'pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages}</span>#{
+          if (p_next  = pagy.next)
+            link.call p_next, pagy_t('pagy.nav.next'), 'style="margin-bottom: 0" aria-label="next" class="next button primary"'
+          else
+            %(<a style="margin-bottom: 0" class="next button primary disabled" href="#">#{pagy_t 'pagy.nav.next'}</a>)
+          end
+        }</div></nav>)
     end
 
-    # Javascript combo pagination for Foundation: it returns a nav and a JSON tag used by the Pagy.combo_nav javascript
-    def pagy_foundation_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-foundation-combo-nav-js" role="navigation" aria-label="Pagination">) + %(<div class="input-group">)
-      html << (p_prev ? link.call(p_prev, pagy_t('pagy.nav.prev'), 'style="margin-bottom: 0px;" aria-label="previous" class="prev button primary"')
-                      : %(<a style="margin-bottom: 0px;" class="prev button primary disabled" href="#">#{pagy_t('pagy.nav.prev')}</a>))
-      input = %(<input class="input-group-field cell shrink" type="number" min="1" max="#{p_pages}" value="#{p_page}" style="width: #{p_pages.to_s.length+1}rem; padding: 0 0.3rem; margin: 0 0.3rem;">)
-      html << %(<span class="input-group-label">#{pagy_t('pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages)}</span>)
-      html << (p_next ? link.call(p_next, pagy_t('pagy.nav.next'), 'style="margin-bottom: 0px;" aria-label="next" class="next button primary"')
-                      : %(<a style="margin-bottom: 0px;" class="next button 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])})
+    private
+
+    def pagy_foundation_prev_html(pagy, link)
+      if (p_prev = pagy.prev)
+        %(<li class="prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</li>)
+      else
+        %(<li class="prev disabled">#{pagy_t 'pagy.nav.prev'}</li>)
+      end
     end
 
+    def pagy_foundation_next_html(pagy, link)
+      if (p_next = pagy.next)
+        %(<li class="next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</li>)
+      else
+        %(<li class="next disabled">#{pagy_t 'pagy.nav.next'}</li>)
+      end
+    end
   end
+  Frontend.prepend FoundationExtra
 end

data/lib/pagy/extras/frontend_helpers.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+class Pagy # :nodoc:
+  DEFAULT[:steps] = false # default false will use {0 => @vars[:size]}
+
+  # Private module documented in the main classes
+  module FrontendHelpers
+    # Additions for the Pagy class
+    module Pagy
+      # `Pagy` instance method used by the `pagy*_nav_js` helpers.
+      # It returns the sequels of width/series generated from the :steps hash
+      # Example:
+      # >> pagy = Pagy.new(count:1000, page: 20, steps: {0 => [1,2,2,1], 350 => [2,3,3,2], 550 => [3,4,4,3]})
+      # >> pagy.sequels
+      # #=> { "0"   => [1, :gap, 18, 19, "20", 21, 22, :gap, 50],
+      #       "350" => [1, 2, :gap, 17, 18, 19, "20", 21, 22, 23, :gap, 49, 50],
+      #       "550" => [1, 2, 3, :gap, 16, 17, 18, 19, "20", 21, 22, 23, 24, :gap, 48, 49, 50] }
+      # Notice: if :steps is false it will use the single {0 => @vars[:size]} size
+      def sequels(steps: @vars[:steps] || { 0 => @vars[:size] }, **_)
+        raise VariableError.new(self, :steps, 'to define the 0 width', steps) unless steps.key?(0)
+
+        {}.tap do |sequels|
+          steps.each { |width, step_size| sequels[width.to_s] = series(size: step_size) }
+        end
+      end
+
+      # Support for the Calendar API
+      def label_sequels(*); end
+    end
+
+    # Additions for Calendar class
+    module Calendar
+      def label_sequels(sequels = self.sequels)
+        {}.tap do |label_sequels|
+          sequels.each do |width, series|
+            label_sequels[width] = series.map { |item| item == :gap ? :gap : label_for(item) }
+          end
+        end
+      end
+    end
+
+    # Additions for the Frontend
+    module Frontend
+      if defined?(Oj)
+        # Return a script tag with the JSON-serialized args generated with the faster oj gem
+        def pagy_json_attr(pagy, *args)
+          args << pagy.vars[:page_param] if pagy.vars[:trim_extra]
+          %(data-pagy-json="#{Oj.dump(args, mode: :strict).gsub('"', '&quot;')}")
+        end
+      else
+        require 'json'
+        # Return a script tag with the JSON-serialized args generated with the slower to_json
+        def pagy_json_attr(pagy, *args)
+          args << pagy.vars[:page_param] if pagy.vars[:trim_extra]
+          %(data-pagy-json="#{args.to_json.gsub('"', '&quot;')}")
+        end
+      end
+
+      # Return the marked link to used by pagy.js
+      def pagy_marked_link(link)
+        link.call PAGE_PLACEHOLDER, '', 'style="display: none;"'
+      end
+    end
+  end
+  prepend FrontendHelpers::Pagy
+  Calendar.prepend FrontendHelpers::Calendar if defined?(Calendar)
+  Frontend.prepend FrontendHelpers::Frontend
+end

data/lib/pagy/extras/gearbox.rb

@@ -0,0 +1,42 @@
+# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/gearbox
+# frozen_string_literal: true
+
+class Pagy # :nodoc:
+  DEFAULT[:gearbox_extra] = true # extra enabled by default
+  DEFAULT[:gearbox_items] = [15, 30, 60, 100]
+
+  # Automatically change the number of items per page depending on the page number
+  # accepts an array as the :gearbox_items variable, that will determine the items for the first pages
+  module GearboxExtra
+    # Setup @items based on the :gearbox_items variable
+    def setup_items_var
+      return super if !@vars[:gearbox_extra] || @vars[:items_extra]
+
+      gearbox_items = @vars[:gearbox_items]
+      raise VariableError.new(self, :gearbox_items, 'to be an Array of positives', gearbox_items) \
+            unless gearbox_items.is_a?(Array) && gearbox_items.all? { |num| num.positive? rescue false } # rubocop:disable Style/RescueModifier
+
+      @items = gearbox_items[@page - 1] || gearbox_items.last
+    end
+
+    # Setup @pages and @last based on the :gearbox_items variable
+    def setup_pages_var
+      return super if !@vars[:gearbox_extra] || @vars[:items_extra]
+
+      gearbox_items = @vars[:gearbox_items]
+      # This algorithm is thousands of times faster than the one in the geared_pagination gem
+      @pages = @last = (if @count > (sum = gearbox_items.sum)
+                          [((@count - sum).to_f / gearbox_items.last).ceil, 1].max + gearbox_items.count
+                        else
+                          pages     = 0
+                          remainder = @count
+                          while remainder.positive?
+                            pages     += 1
+                            remainder -= gearbox_items[pages - 1]
+                          end
+                          [pages, 1].max
+                        end)
+    end
+  end
+  prepend GearboxExtra
+end

data/lib/pagy/extras/headers.rb

@@ -1,39 +1,53 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/headers
-# encoding: utf-8
 # frozen_string_literal: true
 
-class Pagy
-  # Add specialized backend methods to add pagination response headers
-  module Backend ; private
+require 'pagy/url_helpers'
 
-    VARS[:headers] = { page: 'Current-Page', items: 'Page-Items', count: 'Total-Count', pages: 'Total-Pages' }
+class Pagy # :nodoc:
+  DEFAULT[:headers] = { page:  'Current-Page',
+                        items: 'Page-Items',
+                        count: 'Total-Count',
+                        pages: 'Total-Pages' }
+  # Add specialized backend methods to add pagination response headers
+  module HeadersExtra
+    include UrlHelpers
 
-    include Helpers
+    private
 
+    # Merge the pagy headers into the response.headers
     def pagy_headers_merge(pagy)
       response.headers.merge!(pagy_headers(pagy))
     end
 
+    # Generate a hash of RFC-8288 compliant http headers
     def pagy_headers(pagy)
-      hash = pagy_headers_hash(pagy)
-      hash['Link'] = hash['Link'].map{|rel, link| %(<#{link}>; rel="#{rel}")}.join(', ')
-      hash
+      pagy_headers_hash(pagy).tap do |hash|
+        hash['Link'] = hash['Link'].map { |rel, link| %(<#{link}>; rel="#{rel}") }.join(', ')
+      end
     end
 
+    # Generates a hash structure of the headers
     def pagy_headers_hash(pagy)
-      countless = defined?(Pagy::Countless) && pagy.is_a?(Pagy::Countless)
-      rels      = { 'first' => 1, 'prev' => pagy.prev, 'next' => pagy.next }; rels['last'] = pagy.last unless countless
-      url_str   = pagy_url_for(PAGE_PLACEHOLDER, pagy, :url)
-      hash      = { 'Link' => Hash[rels.map{|rel, n|[rel, url_str.sub(PAGE_PLACEHOLDER, n.to_s)] if n}.compact] }
-      headers   = pagy.vars[:headers]
-      hash[headers[:page]]  = pagy.page.to_s         if headers[:page]
-      hash[headers[:items]] = pagy.vars[:items].to_s if headers[:items]
+      countless             = defined?(Countless) && pagy.is_a?(Countless)
+      rel                   = { 'first' => 1, 'prev' => pagy.prev, 'next' => pagy.next }
+      rel['last']           = pagy.last unless countless
+      url_str               = pagy_url_for(pagy, PAGE_PLACEHOLDER, absolute: true)
+      link                  = rel.map do |r, num| # filter_map if ruby >=2.7
+                                next unless num # rubocop:disable Layout/EmptyLineAfterGuardClause
+                                [r, url_str.sub(PAGE_PLACEHOLDER, num.to_s)]
+                              end.compact.to_h
+      hash                  = { 'Link' => link }
+      headers               = pagy.vars[:headers]
+      hash[headers[:page]]  = pagy.page.to_s if headers[:page]
+      if headers[:items] && !(defined?(Calendar) && pagy.is_a?(Calendar))  # items is not for Calendar
+        hash[headers[:items]] = pagy.vars[:items].to_s
+      end
       unless countless
         hash[headers[:pages]] = pagy.pages.to_s if headers[:pages]
-        hash[headers[:count]] = pagy.count.to_s if headers[:count]
+        hash[headers[:count]] = pagy.count.to_s if pagy.count && headers[:count] # count may be nil with Calendar
       end
       hash
     end
-
   end
+  Backend.prepend HeadersExtra
 end

data/lib/pagy/extras/i18n.rb

@@ -1,25 +1,26 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/i18n
-# encoding: utf-8
 # frozen_string_literal: true
 
-class Pagy
+class Pagy # :nodoc:
   # Use ::I18n gem
-  module Frontend
-
-    ::I18n.load_path += Dir[Pagy.root.join('locales', '*.yml')]
-
-    Pagy::I18n.clear.instance_eval { undef :load; undef :t } # unload the pagy default constant for efficiency
-
-    alias_method :pagy_without_i18n, :pagy_t
-    if Gem::Version.new(::I18n::VERSION) < Gem::Version.new('1.6.0')
-      def pagy_t_with_i18n(*args) ::I18n.t(*args) end
-    else
-      # keep 1.9 compatibility by hiding 2.0+ syntax in string
-      module_eval <<-RUBY
-        def pagy_t_with_i18n(key, **opts) ::I18n.t(key, **opts) end
-      RUBY
+  module I18nExtra
+    # Frontend overriding for translation
+    module Frontend
+      def pagy_t(key, **opts)
+        ::I18n.t(key, **opts)
+      end
     end
-    alias_method :pagy_t, :pagy_t_with_i18n
 
+    # Calendar overriding for localization (see also the block in the calendar section of the config/pagy.rb initializer)
+    module Calendar
+      def localize(time, opts)
+        ::I18n.l(time, **opts)
+      end
+    end
   end
+  Frontend.prepend I18nExtra::Frontend
+  Calendar.prepend I18nExtra::Calendar if defined?(Calendar)
+
+  # Add the pagy locales to the I18n.load_path
+  ::I18n.load_path += Dir[Pagy.root.join('locales', '*.yml')]
 end