pagy 9.3.5 → 43.0.0.rc1

data/lib/pagy/modules/i18n/p11n/polish.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      module Polish
+        module_function
+
+        def plural_for(n = 0)
+          mod10  = n % 10
+          mod100 = n % 100
+          case
+          when n == 1
+            :one
+          when [2, 3, 4].include?(mod10) && ![12, 13, 14].include?(mod100)
+            :few
+          when [0, 1, 5, 6, 7, 8, 9].include?(mod10) || [12, 13, 14].include?(mod100)
+            :many
+          else
+            :other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n/west_slavic.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      module WestSlavic
+        module_function
+
+        def plural_for(n = 0)
+          case n
+          when 1
+            :one
+          when 2, 3, 4
+            :few
+          else
+            :other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      path = ROOT.join('lib/pagy/modules/i18n/p11n')
+      autoload :Arabic,          path.join('arabic')
+      autoload :EastSlavic,      path.join('east_slavic')
+      autoload :OneOther,        path.join('one_other')
+      autoload :OneUptoTwoOther, path.join('one_upto_two_other')
+      autoload :Other,           path.join('other')
+      autoload :Polish,          path.join('polish')
+      autoload :WestSlavic,      path.join('west_slavic')
+    end
+  end
+end

data/lib/pagy/modules/searcher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Relegate internal functions. Make overriding search classes easier.
+  module Searcher
+    module_function
+
+    # Common search logic
+    def wrap(context, pagy_search_args, options)
+      context.instance_exec do
+        options[:request] = Request.new(options[:request] || request, options)
+        options[:page]  ||= options[:request].resolve_page(options)
+        options[:limit] ||= options[:request].resolve_limit(options)
+      end
+      pagy, results = yield
+      calling = pagy_search_args[4..]
+      [pagy, calling.empty? ? results : results.send(*calling)]
+    end
+  end
+end

data/lib/pagy/toolbox/helpers/anchor_tags.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'support/a_lambda' # inheritable
+
+class Pagy
+  # Return the enabled/disabled previous page anchor tag
+  def previous_tag(a = nil, text: I18n.translate('pagy.previous'),
+                   aria_label: I18n.translate('pagy.aria_label.previous'), **)
+    if @previous
+      (a || a_lambda(**)).(@previous, text, aria_label:)
+    else
+      %(<a role="link" aria-disabled="true" aria-label="#{aria_label}">#{text}</a>)
+    end
+  end
+
+  # Return the enabled/disabled next page anchor tag
+  def next_tag(a = nil, text: I18n.translate('pagy.next'),
+               aria_label: I18n.translate('pagy.aria_label.next'), **)
+    if @next
+      (a || a_lambda(**)).(@next, text, aria_label:)
+    else
+      %(<a role="link" aria-disabled="true" aria-label="#{aria_label}">#{text}</a>)
+    end
+  end
+end

data/lib/pagy/toolbox/helpers/bootstrap/input_nav_js.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_input_nav_js'
+
+class Pagy
+  private
+
+  # Javascript combo pagination for bootstrap: it returns a nav with a data-pagy attribute used by the pagy.js file
+  def bootstrap_input_nav_js(classes: 'pagination', **)
+    a_lambda = a_lambda(**)
+    input    = %(<input name="page" type="number" min="1" max="#{last}" value="#{@page}" aria-current="page" ) +
+               %(style="text-align: center; width: #{@page.to_s.length + 1}rem; padding: 0; border-radius: .25rem; ) +
+               %(border: none; display: inline-block;" class="page-link active">#{A_TAG})
+    html     = %(<ul class="#{classes}">#{
+                 bootstrap_html_for(:previous, a_lambda)
+                 }<li class="page-item"><label class="page-link">#{
+                 I18n.translate('pagy.input_nav_js', page_input: input, pages: @last)
+                 }</label></li>#{
+                 bootstrap_html_for(:next, a_lambda)
+                 }</ul>)
+    wrap_input_nav_js(html, 'pagy-bootstrap input-nav-js', **)
+  end
+end

data/lib/pagy/toolbox/helpers/bootstrap/previous_next_html.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Pagy
+  private
+
+  # Return the enabled/disabled previous/next page anchor tag, embedded in the li tag
+  def bootstrap_html_for(which, a_lambda)
+    if send(which)
+      %(<li class="page-item #{which}">#{
+        a_lambda.(send(which), I18n.translate("pagy.#{which}"),
+                  classes:    'page-link',
+                  aria_label: I18n.translate("pagy.aria_label.#{which}"))}</li>)
+    else
+      %(<li class="page-item #{which} disabled"><a role="link" class="page-link" aria-disabled="true" aria-label="#{
+      I18n.translate("pagy.aria_label.#{which}")}">#{I18n.translate("pagy.#{which}")}</a></li>)
+    end
+  end
+end

data/lib/pagy/toolbox/helpers/bootstrap/series_nav.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_series_nav'
+
+class Pagy
+  private
+
+  # Pagination for bootstrap: it returns the html with the series of links to the pages
+  def bootstrap_series_nav(classes: 'pagination', **)
+    a_lambda = a_lambda(**)
+    html     = %(<ul class="#{classes}">#{bootstrap_html_for(:previous, a_lambda)})
+    series(**).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+      html << case item
+              when Integer
+                %(<li class="page-item">#{a_lambda.(item, classes: 'page-link')}</li>)
+              when String
+                %(<li class="page-item active"><a role="link" class="page-link" aria-current="page" aria-disabled="true">#{
+                    page_label(item)}</a></li>)
+              when :gap
+                %(<li class="page-item gap disabled"><a role="link" class="page-link" aria-disabled="true">#{
+                  I18n.translate('pagy.gap')}</a></li>)
+              else raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
+              end
+    end
+    html << %(#{bootstrap_html_for(:next, a_lambda)}</ul>)
+    wrap_series_nav(html, 'pagy-bootstrap series-nav', **)
+  end
+end

data/lib/pagy/toolbox/helpers/bootstrap/series_nav_js.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_series_nav_js'
+
+class Pagy
+  private
+
+  # Javascript pagination for bootstrap: it returns a nav with a data-pagy attribute used by the pagy.js file
+  def bootstrap_series_nav_js(classes: 'pagination', **)
+    a_lambda = a_lambda(**)
+    tokens   = { before:  %(<ul class="#{classes}">#{bootstrap_html_for(:previous, a_lambda)}),
+                 anchor:  %(<li class="page-item">#{a_lambda.(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">#{
+                            I18n.translate('pagy.gap')}</a></li>),
+                 after:   %(#{bootstrap_html_for(:next, a_lambda)}</ul>) }
+    wrap_series_nav_js(tokens, 'pagy-bootstrap series-nav-js', **)
+  end
+end

data/lib/pagy/toolbox/helpers/bulma/input_nav_js.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_input_nav_js'
+
+class Pagy
+  private
+
+  # Javascript combo pagination for bulma: it returns a nav with a data-pagy attribute used by the pagy.js file
+  def bulma_input_nav_js(classes: 'pagination', **)
+    a_lambda = a_lambda(**)
+    input    = %(<input name="page" type="number" min="1" max="#{@last}" value="#{@page}" aria-current="page") +
+               %(style="text-align: center; width: #{@page.to_s.length + 1}rem; line-height: 1.2rem; ) +
+               %(border: none; border-radius: .25rem; padding: .0625rem; color: white; ) +
+               %(background-color: #485fc7;">#{A_TAG})
+    html     = %(<ul class="pagination-list">#{bulma_html_for(:previous, a_lambda)}<li class="pagination-link"><label>#{
+                 I18n.translate('pagy.input_nav_js', page_input: input, pages: @last)
+                 }</label></li>#{bulma_html_for(:next, a_lambda)}</ul>)
+    wrap_input_nav_js(html, "pagy-bulma input-nav-js #{classes}", **)
+  end
+end

data/lib/pagy/toolbox/helpers/bulma/previous_next_html.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Pagy
+  private
+
+  # Return the enabled/disabled previous/next page anchor tag
+  def bulma_html_for(which, a_lambda)
+    %(<li>#{
+      if send(which)
+        a_lambda.(send(which), I18n.translate("pagy.#{which}"),
+                  classes: "pagination-#{which}",
+                  aria_label: I18n.translate("pagy.aria_label.#{which}"))
+      else
+        %(<a role="link" class="pagination-#{which}" disabled aria-disabled="true" aria-label="#{
+        I18n.translate("pagy.aria_label.#{which}")}">#{I18n.translate("pagy.#{which}")}</a>)
+      end
+      }</li>)
+  end
+end

data/lib/pagy/toolbox/helpers/bulma/series_nav.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_series_nav'
+
+class Pagy
+  private
+
+  # Pagination for bulma: it returns the html with the series of links to the pages
+  def bulma_series_nav(classes: 'pagination', **)
+    a_lambda = a_lambda(**)
+    html     = %(<ul class="pagination-list">#{bulma_html_for(:previous, a_lambda)})
+    series(**).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+      html << case item
+              when Integer
+                %(<li>#{a_lambda.(item, page_label(item), classes: 'pagination-link')}</li>)
+              when String
+                %(<li><a role="link" class="pagination-link is-current" aria-current="page" aria-disabled="true">#{
+                  page_label(item)}</a></li>)
+              when :gap
+                %(<li><span class="pagination-ellipsis">#{I18n.translate('pagy.gap')}</span></li>)
+              else raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
+              end
+    end
+    html << %(#{bulma_html_for(:next, a_lambda)}</ul>)
+    wrap_series_nav(html, "pagy-bulma series-nav #{classes}", **)
+  end
+end

data/lib/pagy/toolbox/helpers/bulma/series_nav_js.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_series_nav_js'
+
+class Pagy
+  private
+
+  # Javascript pagination for bulma: it returns a nav with a data-pagy attribute used by the Pagy.nav javascript
+  def bulma_series_nav_js(classes: 'pagination', **)
+    a_lambda = a_lambda(**)
+    tokens   = { before:  %(<ul class="pagination-list">#{bulma_html_for(:previous, a_lambda)}),
+                 anchor:  %(<li>#{a_lambda.(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">#{I18n.translate('pagy.gap')}</span></li>),
+                 after:   %(#{bulma_html_for(:next, a_lambda)}</ul>) }
+    wrap_series_nav_js(tokens, "pagy-bulma series-nav-js #{classes}", **)
+  end
+end

data/lib/pagy/toolbox/helpers/data_hash.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Generate a hash of the wanted internal data
+  def data_hash(data_keys: @options[:data_keys] ||
+    %i[url_template first_url previous_url page_url next_url last_url
+       count page limit last in from to previous next options], **)
+    data_keys   -= %i[count limit] if calendar?
+    url_template = compose_page_url(PAGE_TOKEN, **)
+    {}.tap do |data|
+      data_keys.each do |key|
+        data[key] = case key
+                    when :url_template then url_template
+                    when :first_url    then compose_page_url(nil, **)
+                    when :previous_url then url_template.sub(PAGE_TOKEN, @previous.to_s)
+                    when :page_url     then url_template.sub(PAGE_TOKEN, @page.to_s)
+                    when :next_url     then url_template.sub(PAGE_TOKEN, @next.to_s)
+                    when :last_url     then url_template.sub(PAGE_TOKEN, @last.to_s)
+                    else send(key)
+                    end
+      rescue NoMethodError
+        raise OptionError.new(self, :data, 'to contain known keys', key)
+      end
+    end
+  end
+end

data/lib/pagy/toolbox/helpers/headers_hash.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'urls_hash'
+
+# Add pagination response headers
+class Pagy
+  # Generate a hash of RFC-8288-compliant http headers
+  def headers_hash(headers_map: @options[:headers_map] ||
+    { page: 'current-page', limit: 'page-limit', count: 'total-count', pages: 'total-pages' }, **)
+    links = urls_hash(**, absolute: true).map { |key, url| %(<#{url}>; rel="#{key}") }.join(', ')
+    { 'link' => links }.tap do |hash|
+      hash[headers_map[:page]]  = @page.to_s if @page && headers_map[:page]
+      hash[headers_map[:limit]] = @limit.to_s if headers_map[:limit] && !calendar?
+      return hash unless @count
+
+      hash[headers_map[:pages]] = @last.to_s if headers_map[:pages]
+      hash[headers_map[:count]] = @count.to_s if headers_map[:count]
+    end
+  end
+end

data/lib/pagy/toolbox/helpers/info_tag.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Instances with count return "Displaying items 41-60 of 324 in total" or "Displaying Products 41-60 of 324 in total"
+  # Instances with no count return only page info: "Page 3 of 100"
+  def info_tag(id: nil, item_name: nil)
+    i18n_key  = if @count.nil?
+                  'pagy.info_tag.no_count'
+                elsif @count.zero?
+                  'pagy.info_tag.no_items'
+                elsif @last == 1
+                  'pagy.info_tag.single_page'
+                else
+                  'pagy.info_tag.multiple_pages'
+                end
+    info_data = if @count.nil?
+                  { page: @page, pages: @last }
+                else
+                  { item_name: item_name || I18n.translate('pagy.item_name', count: @count),
+                    count:     @count,
+                    from:      @from,
+                    to:        @to }
+                end
+    %(<span#{%( id="#{id}") if id} class="pagy info">#{I18n.translate(i18n_key, **info_data)}</span>)
+  end
+end

data/lib/pagy/toolbox/helpers/input_nav_js.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'support/wrap_input_nav_js'
+
+class Pagy
+  # Javascript combo pagination: it returns a nav with a data-pagy attribute used by the pagy.js file
+  def input_nav_js(style = nil, **)
+    return send(:"#{style}_input_nav_js", **) if style
+
+    a_lambda = a_lambda(**)
+    input    = %(<input name="page" type="number" min="1" max="#{@last}" value="#{@page}" aria-current="page" ) +
+               %(style="text-align: center; width: #{@page.to_s.length + 1}rem; padding: 0;">#{A_TAG})
+    html     = %(#{previous_tag(a_lambda)}<label>#{
+                 I18n.translate('pagy.input_nav_js', page_input: input, pages: @last)}</label>#{
+                 next_tag(a_lambda)})
+    wrap_input_nav_js(html, 'pagy input-nav-js', **)
+  end
+  alias pagy_input_nav_js input_nav_js
+end

data/lib/pagy/toolbox/helpers/limit_tag_js.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'support/data_pagy_attribute'
+
+class Pagy
+  # Return the limit selector HTML. For example "Show [20] items per page"
+  def limit_tag_js(id: nil, item_name: nil, client_max_limit: @options[:client_max_limit], **)
+    raise OptionError.new(self, :client_max_limit, 'to be truthy', client_max_limit) unless client_max_limit
+
+    url_token   = compose_page_url(PAGE_TOKEN, limit_token: LIMIT_TOKEN)
+    limit_input = %(<input name="limit" type="number" min="1" max="#{@options[:client_max_limit]}" value="#{
+                    @limit}" style="padding: 0; text-align: center; width: #{@limit.to_s.length + 1}rem;">#{A_TAG})
+
+    %(<span#{%( id="#{id}") if id} class="pagy limit-tag-js" #{
+      data_pagy_attribute(:ltj, @from, url_token)
+      }><label>#{
+      I18n.translate('pagy.limit_tag_js',
+                     item_name: item_name || I18n.translate('pagy.item_name', count: @limit),
+                     limit_input:,
+                     count: @limit)
+      }</label></span>)
+  end
+end

data/lib/pagy/toolbox/helpers/loader.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Pagy
+  module Loader
+    paths = { public:    { page_url:                'page_url',
+                           data_hash:               'data_hash',
+                           headers_hash:            'headers_hash',
+                           urls_hash:               'urls_hash',
+                           next_tag:                'anchor_tags',
+                           previous_tag:            'anchor_tags',
+                           input_nav_js:            'input_nav_js',
+                           info_tag:                'info_tag',
+                           limit_tag_js:            'limit_tag_js',
+                           series_nav:              'series_nav',
+                           series_nav_js:           'series_nav_js' },
+              protected: { bootstrap_series_nav:    'bootstrap/series_nav',
+                           bootstrap_series_nav_js: 'bootstrap/series_nav_js',
+                           bootstrap_input_nav_js:  'bootstrap/input_nav_js',
+                           bulma_series_nav:        'bulma/series_nav',
+                           bulma_series_nav_js:     'bulma/series_nav_js',
+                           bulma_input_nav_js:      'bulma/input_nav_js' } }.freeze
+
+    paths.each do |visibility, methods|
+      send(visibility)
+      # Load the method, overriding its own alias. Next requests will call the method directly.
+      define_method(:"load_#{visibility}") do |*args, **kwargs|
+        require_relative methods[__callee__]
+        send(__callee__, *args, **kwargs)
+      end
+      methods.each_key { |method| alias_method method, :"load_#{visibility}" }
+    end
+  end
+end

data/lib/pagy/toolbox/helpers/page_url.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Return the page url for any page
+  # :nocov:
+  def page_url(page, **)
+    case page
+    when :first
+      compose_page_url(nil, **)
+    when :current
+      compose_page_url(@page, **) if @page
+    when :previous
+      compose_page_url(@previous, **) if @previous
+    when :next
+      compose_page_url(@next, **) if @next
+    when :last
+      compose_page_url(@last, **) if @last
+    when Integer, String
+      compose_page_url(page, **)
+    end
+  end
+  # :nocov:
+end

data/lib/pagy/toolbox/helpers/series_nav.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'support/wrap_series_nav'
+
+class Pagy
+  # Return the html with the series of links to the pages
+  def series_nav(style = nil, **)
+    return send(:"#{style}_series_nav", **) if style
+
+    a_lambda = a_lambda(**)
+    html     = previous_tag(a_lambda)
+    series(**).each do |item|
+      # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+      html << case item
+              when Integer
+                a_lambda.(item)
+              when String
+                %(<a role="link" aria-disabled="true" aria-current="page">#{page_label(item)}</a>)
+              when :gap
+                %(<a role="separator" aria-disabled="true">#{I18n.translate('pagy.gap')}</a>)
+              else
+                raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
+              end
+    end
+    html << next_tag(a_lambda)
+    wrap_series_nav(html, 'pagy series-nav', **)
+  end
+  alias pagy_series_nav series_nav
+end

data/lib/pagy/toolbox/helpers/series_nav_js.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'support/wrap_series_nav_js'
+
+class Pagy
+  # Return a nav with a data-pagy attribute used by the pagy.js file
+  def series_nav_js(style = nil, **)
+    return send(:"#{style}_series_nav_js", **) if style
+
+    a_lambda = a_lambda(**)
+    tokens   = { before:  previous_tag(a_lambda),
+                 anchor:  a_lambda.(PAGE_TOKEN, LABEL_TOKEN),
+                 current: %(<a role="link" aria-current="page" aria-disabled="true">#{LABEL_TOKEN}</a>),
+                 gap:     %(<a role="separator" aria-disabled="true">#{I18n.translate('pagy.gap')}</a>),
+                 after:   next_tag(a_lambda) }
+    wrap_series_nav_js(tokens, 'pagy series-nav-js', **)
+  end
+  alias pagy_series_nav_js series_nav_js
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Pagy
+  protected
+
+  # Label for any page. Allow the customization of the output
+  def page_label(page, **options)
+    return page.to_s unless calendar?
+
+    options[:format] ||= @options[:format]
+    localize(starting_time_for(page.to_i), **options)  # page could be a string
+  end
+
+  # Return a performance optimized lambda to generate the anchor tag
+  # Benchmarked on a 20 link nav: it is ~22x faster and uses ~18x less memory than rails' link_to
+  def a_lambda(**)
+    left, right = %(<a href="#{compose_page_url(PAGE_TOKEN, **)}").split(PAGE_TOKEN, 2)
+
+    lambda do |page, text = page_label(page), classes: nil, aria_label: nil|
+      title = if (counts = @options[:counts]) # only for calendar + counts
+                count    = counts[page - 1]
+                classes  = classes ? "#{classes} empty-page" : 'empty-page' if count.zero?
+                info_key = count.zero? ? 'pagy.info_tag.no_items' : 'pagy.info_tag.single_page'
+                %( title="#{I18n.translate(info_key, item_name: I18n.translate('pagy.item_name', count:), count:)}")
+              end
+      rel   = case page
+              when @previous then %( rel="prev")
+              when @next     then %( rel="next")
+              end
+      %(#{left}#{page}#{right}#{title}#{
+        %( class="#{classes}") if classes}#{rel}#{%( aria-label="#{aria_label}") if aria_label}>#{text}</a>)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../../../modules/b64'
+
+# Relegate internal functions. Make overriding navs easier.
+class Pagy
+  private
+
+  # Compose the data-pagy attribute, with the base64 encoded JSON-serialized args. Use the faster oj gem if defined.
+  def data_pagy_attribute(*args)
+    data = defined?(Oj) ? Oj.dump(args, mode: :compat) : JSON.dump(args)
+    %(data-pagy="#{B64.encode(data)}")
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Relegate internal functions. Make overriding navs easier.
+class Pagy
+  private
+
+  # Compose the aria label attribute for the nav
+  def nav_aria_label_attribute(aria_label: nil)
+    aria_label ||= I18n.translate('pagy.aria_label.nav', count: @last)
+    %(aria-label="#{aria_label}")
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Pagy
+  SERIES_SLOTS = 7
+
+  protected
+
+  # Return the array of page numbers and :gap e.g. [1, :gap, 8, "9", 10, :gap, 36]
+  def series(slots: @options[:slots] || SERIES_SLOTS, compact: @options[:compact], **)
+    raise OptionError.new(self, :slots, 'to be an Integer >= 0', slots) \
+          unless slots.is_a?(Integer) && slots >= 0
+    return [] if slots.zero?
+
+    [].tap do |series|
+      if slots >= @last
+        series.push(*1..@last)
+      else
+        half  = (slots - 1) / 2                       # the left half might be 1 page shorter when the slots are even
+        start = if @page <= half                      # @page in the first half
+                  1
+                elsif @page > (@last - slots + half)  # @page in the last half
+                  @last - slots + 1
+                else                                  # @page in the middle
+                  @page - half
+                end
+        series.push(*(start...(start + slots)))
+        unless compact || slots < SERIES_SLOTS        # Set first, last and :gap when needed
+          series[0]  = 1
+          series[1]  = :gap unless series[1]  == 2
+          series[-2] = :gap unless series[-2] == @last - 1
+          series[-1] = @last
+        end
+      end
+      current = series.index(@page)
+      series[current] = @page.to_s if current
+    end
+  end
+end