pagy 43.0.0 → 43.3.0

data/lib/pagy/modules/console.rb

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

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

@@ -6,42 +6,66 @@ require_relative 'p11n'
 class Pagy
   # Pagy i18n implementation, compatible with the I18n gem, just a lot faster and lighter
   module I18n
+    class KeyError < KeyError; end
+
     extend self
 
-    def pathnames = @pathnames ||= [ROOT.join('locales')]
-    def locales   = @locales   ||= {}
+    def pathnames
+      @pathnames ||= [ROOT.join('locales')]
+    end
+
+    def locales
+      @locales ||= {}
+    end
 
     # Store the variable for the duration of a single request
     def locale=(value)
-      Thread.current[:pagy_locale] = value
+      Thread.current[:pagy_locale] = value.to_s
     end
 
-    def locale = Thread.current[:pagy_locale] || 'en'
+    def locale
+      Thread.current[:pagy_locale] || 'en'
+    end
 
     # Translate and pluralize the key with the locale entries
     def translate(key, **options)
-      data, p11n  = locales[locale] || self.load
-      translation = data[key] || (options[:count] && data[key += ".#{p11n.plural_for(options[:count])}"]) \
-                      or return %([translation missing: "#{key}"])
-      translation.gsub(/%{[^}]+?}/) { |match| options[:"#{match[2..-2]}"] || match }
+      data, p11n = locales[locale] || self.load
+      key       += ".#{p11n.plural_for(options[:count])}" if !data[key] && options[:count]
+
+      translation = data[key] or return %([translation missing: "#{key}"])
+
+      translation.gsub(/%{[^}]+?}/) { options.fetch(_1[2..-2].to_sym, _1) } # replace the interpolation placeholders
     end
 
     private
 
-    def load
+    def load(locale: self.locale)
       path = pathnames.reverse.map { |p| p.join("#{locale}.yml") }.find(&:exist?)
-      raise Errno::ENOENT, "missing dictionary file for #{locale.inspect} locale" unless path
+      unless path
+        warn %(Pagy::I18n: missing dictionary file for #{locale.inspect} locale; using "en" instead)
+        return locales[locale] = locales['en'] || load(locale: 'en')
+      end
+
+      dictionary = YAML.load_file(path)[locale]
+      raise KeyError, "missing 'pagy' key in #{locale.inspect} locale" unless dictionary['pagy']
+
+      p11n = dictionary['pagy'].delete('p11n')
+      raise KeyError, "missing 'p11n' key in #{locale.inspect} locale" unless p11n
 
-      dictionary      = YAML.load_file(path)[locale]
-      p11n            = dictionary['pagy'].delete('p11n')
       locales[locale] = [flatten_to_dot_keys(dictionary), Object.const_get("Pagy::I18n::P11n::#{p11n}")]
     end
 
     # Create a flat hash with dotted notation keys
     # e.g. { 'a' => { 'b' => {'c' => 3, 'd' => 4 }}} -> { 'a.b.c' => 3, 'a.b.d' => 4 }
     def flatten_to_dot_keys(initial, prefix = '')
-      initial.reduce({}) do |hash, (key, value)|
-        hash.merge!(value.is_a?(Hash) ? flatten_to_dot_keys(value, "#{prefix}#{key}.") : { "#{prefix}#{key}" => value })
+      initial.each_with_object({}) do |(key, value), hash|
+        key = "#{prefix}#{key}"
+
+        if value.is_a?(Hash)
+          hash.merge!(flatten_to_dot_keys(value, "#{key}."))
+        else
+          hash[key] = value
+        end
       end
     end
   end

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

@@ -8,6 +8,7 @@ class Pagy
 
         def plural_for(n = 0)
           mod100 = n % 100
+
           case
           when n == 0  # rubocop:disable Style/NumericPredicate
             :zero

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

@@ -9,6 +9,7 @@ class Pagy
         def plural_for(n = 0)
           mod10  = n % 10
           mod100 = n % 100
+
           case
           when mod10 == 1 && mod100 != 11
             :one

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

@@ -9,6 +9,7 @@ class Pagy
         def plural_for(n = 0)
           mod10  = n % 10
           mod100 = n % 100
+
           case
           when n == 1
             :one

data/lib/pagy/modules/searcher.rb

@@ -6,15 +6,16 @@ class Pagy
     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
+    def wrap(search_arguments, options)
+      options[:page] ||= options[:request].resolve_page
+      options[:limit]  = options[:request].resolve_limit
+
       pagy, results = yield
-      calling = pagy_search_args[4..]
-      [pagy, calling.empty? ? results : results.send(*calling)]
+
+      called  = search_arguments[4..]
+      results = results.send(*called) unless called.empty?
+
+      [pagy, results]
     end
   end
 end

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

@@ -4,22 +4,18 @@ 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
+  def previous_tag(...) = anchor_tag_for(:previous, ...)
 
   # 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
+  def next_tag(...) = anchor_tag_for(:next, ...)
+
+  private
+
+  def anchor_tag_for(which, a = nil, text: I18n.translate("pagy.#{which}"),
+                     aria_label: I18n.translate("pagy.aria_label.#{which}"), **)
+    page = send(which)
+    return (a || a_lambda(**)).(page.to_i, text, aria_label:) if page
+
+    %(<a role="link" aria-disabled="true" aria-label="#{aria_label}">#{text}</a>)
   end
 end

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

@@ -9,9 +9,11 @@ class Pagy
   # 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">#{
@@ -19,6 +21,7 @@ class Pagy
                  }</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/series_nav.rb

@@ -9,7 +9,8 @@ class Pagy
   # 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)})
+
+    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
@@ -24,6 +25,7 @@ class Pagy
               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

@@ -9,6 +9,7 @@ class Pagy
   # 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" ) +
@@ -16,6 +17,7 @@ class Pagy
                  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

@@ -9,13 +9,16 @@ class Pagy
   # 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

@@ -8,7 +8,7 @@ class Pagy
     %(<li>#{
       if send(which)
         a_lambda.(send(which), I18n.translate("pagy.#{which}"),
-                  classes: "pagination-#{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="#{

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

@@ -9,7 +9,8 @@ class Pagy
   # 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)})
+
+    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
@@ -23,6 +24,7 @@ class Pagy
               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

@@ -9,12 +9,14 @@ class Pagy
   # 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

@@ -1,27 +1,29 @@
 # frozen_string_literal: true
 
 class Pagy
-  DEFAULT_DATA_KEYS = %i[url_template first_url previous_url page_url next_url last_url
+  DEFAULT_DATA_KEYS = %i[url_template first_url previous_url current_url page_url next_url last_url
                          count page limit last in from to previous next options].freeze
 
   # Generate a hash of the wanted internal data
   def data_hash(data_keys: @options[:data_keys] || DEFAULT_DATA_KEYS, **)
-    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
+    template = compose_page_url(PAGE_TOKEN, **)
+    to_url   = ->(page) { template.sub(PAGE_TOKEN, page.to_s) if page }
+
+    data_keys -= %i[count limit] if calendar?
+
+    data_keys.each_with_object({}) do |key, data|
+      value = case key
+              when :url_template           then template
+              when :first_url              then compose_page_url(nil, **)
+              when :previous_url           then to_url.(@previous)
+              when :current_url, :page_url then to_url.(@page)
+              when :next_url               then to_url.(@next)
+              when :last_url               then to_url.(@last)
+              else send(key)
+              end
+      data[key] = value if value
+    rescue NoMethodError
+      raise OptionError.new(self, :data_keys, 'to contain known keys/methods', key)
     end
   end
 end

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

@@ -4,21 +4,27 @@ require_relative 'urls_hash'
 
 # Add pagination response headers
 class Pagy
-  DEFAULT_HEADERS_MAP = { page: 'current-page',
+  DEFAULT_HEADERS_MAP = { page:  'current-page',
                           limit: 'page-limit',
                           count: 'total-count',
                           pages: 'total-pages' }.freeze
 
   # Generate a hash of RFC-8288-compliant http headers
   def headers_hash(headers_map: @options[:headers_map] || DEFAULT_HEADERS_MAP, **)
-    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?
-      if @count
-        hash[headers_map[:pages]] = @last.to_s if headers_map[:pages]
-        hash[headers_map[:count]] = @count.to_s if headers_map[:count]
-      end
+    links = urls_hash(**, absolute: true).map { %(<#{_2}>; rel="#{_1}") }.join(', ')
+
+    headers_map.each_with_object('link' => links) do |(key, name), hash|
+      next unless name
+
+      value = case key
+              # :nocov:
+              when :page  then @page
+              when :limit then @limit unless calendar?
+              when :pages then @last  if @count
+              when :count then @count
+                # :nocov:
+              end
+      hash[name] = value.to_s if value
     end
   end
 end

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

@@ -13,6 +13,7 @@ class Pagy
                 else
                   'pagy.info_tag.multiple_pages'
                 end
+
     info_data = if @count.nil?
                   { page: @page, pages: @last }
                 else
@@ -21,6 +22,7 @@ class Pagy
                     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

@@ -5,14 +5,17 @@ require_relative 'support/wrap_input_nav_js'
 class Pagy
   # JavaScript input 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
+    return send(:"#{style}_input_nav_js", **) if style && style.to_s != 'pagy'
 
     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)})
+
+    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
 end

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

@@ -7,12 +7,13 @@ class Pagy
   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_input = %(<input name="limit" type="number" min="1" max="#{client_max_limit}" value="#{
                     @limit}" style="padding: 0; text-align: center; width: #{@limit.to_s.length + 1}rem;">#{A_TAG})
 
+    url_token = compose_page_url(PAGE_TOKEN, limit: LIMIT_TOKEN)
+
     %(<span#{%( id="#{id}") if id} class="pagy limit-tag-js" #{
-      data_pagy_attribute(:ltj, @from, url_token)
+      data_pagy_attribute(:ltj, @from, url_token, PAGE_TOKEN, LIMIT_TOKEN)
       }><label>#{
       I18n.translate('pagy.limit_tag_js',
                      item_name: item_name || I18n.translate('pagy.item_name', count: @limit),

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

@@ -24,8 +24,11 @@ class Pagy
       send(visibility)
       # Load the method, overriding its own alias. Next requests will call the method directly.
       define_method(:"load_#{visibility}") do |*args, **kwargs|
+        # Tests shadow the usage of these lines
+        # :nocov:
         require_relative methods[__callee__]
         send(__callee__, *args, **kwargs)
+        # :nocov:
       end
       methods.each_key { |method| alias_method method, :"load_#{visibility}" }
     end

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

@@ -2,22 +2,16 @@
 
 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
+    target = case page
+             when :first          then nil
+             when :current, :page then @page
+             when :previous       then @previous
+             when :next           then @next
+             when :last           then @last
+             else                      page
+             end
+
+    compose_page_url(target, **) if target || page == :first
   end
-  # :nocov:
 end

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

@@ -5,12 +5,12 @@ 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
+    return send(:"#{style}_series_nav", **) if style && style.to_s != 'pagy'
 
     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 = 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)
@@ -23,6 +23,7 @@ class Pagy
               end
     end
     html << next_tag(a_lambda)
+
     wrap_series_nav(html, 'pagy series-nav', **)
   end
 end

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

@@ -5,7 +5,7 @@ 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
+    return send(:"#{style}_series_nav_js", **) if style && style.to_s != 'pagy'
 
     a_lambda = a_lambda(**)
     tokens   = { before:  previous_tag(a_lambda),
@@ -13,6 +13,7 @@ class Pagy
                  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
 end

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

@@ -13,21 +13,23 @@ class Pagy
 
   # 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(anchor_string: nil, **)
+  def a_lambda(anchor_string: @options[:anchor_string], **)
     left, right = %(<a href="#{compose_page_url(PAGE_TOKEN, **)}"#{
                     %( #{anchor_string}) if anchor_string}).split(PAGE_TOKEN, 2)
 
     lambda do |page, text = page_label(page), classes: nil, aria_label: nil|
-      title = if (counts = @options[:counts]) # only for calendar + counts
+      title = if (counts = @options[:counts]) # only for calendar with counts
                 count    = counts[page - 1]
                 classes  = classes ? "#{classes} empty-page" : 'empty-page' if count.zero?
                 info_key = count.zero? ? 'pagy.info_tag.no_items' : 'pagy.info_tag.single_page'
                 %( 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
+
+      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

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

@@ -9,7 +9,12 @@ class Pagy
 
   # 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 = if defined?(Oj)
+             Oj.dump(args, mode: :compat)
+           else
+             JSON.dump(args)
+           end
+
     %(data-pagy="#{B64.encode(data)}")
   end
 end

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

@@ -7,8 +7,7 @@ class Pagy
 
   # 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
+    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|

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

@@ -12,7 +12,7 @@ class Pagy
   def wrap_input_nav_js(html, nav_classes, id: nil, aria_label: nil, **)
     %(<nav#{%( id="#{id}") if id} class="#{nav_classes}" #{
       nav_aria_label_attribute(aria_label:)} #{
-      data = [:inj, compose_page_url(PAGE_TOKEN, **)]
+      data = [:inj, compose_page_url(PAGE_TOKEN, **), PAGE_TOKEN]
       data.push(@update) if keynav?
       data_pagy_attribute(*data)
       }>#{html}</nav>)