pagy 3.8.2 → 9.4.0

data/lib/pagy/extras/overflow.rb

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

data/lib/pagy/extras/pagy.rb

@@ -0,0 +1,82 @@
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/pagy
+# frozen_string_literal: true
+
+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 PagyExtra
+    # pagy_nav is defined in the Frontend itself
+    # Javascript pagination: it returns a nav with a data-pagy attribute used by the pagy.js file
+    def pagy_nav_js(pagy, id: nil, aria_label: nil, **vars)
+      sequels = pagy.sequels(**vars)
+      id      = %( id="#{id}") if id
+      a       = pagy_anchor(pagy, **vars)
+      tokens  = { 'before'  => prev_a(pagy, a),
+                  'a'       => a.(PAGE_TOKEN, LABEL_TOKEN),
+                  'current' => %(<a class="current" role="link" aria-current="page" aria-disabled="true">#{
+                                   LABEL_TOKEN}</a>),
+                  'gap'     => %(<a class="gap" role="link" aria-disabled="true">#{pagy_t('pagy.gap')}</a>),
+                  'after'   => next_a(pagy, a) }
+
+      %(<nav#{id} class="#{'pagy-rjs ' if sequels.size > 1}pagy nav-js" #{
+          nav_aria_label(pagy, aria_label:)} #{
+          pagy_data(pagy, :nav, tokens, sequels, pagy.label_sequels(sequels))
+        }></nav>)
+    end
+
+    # Javascript combo pagination: it returns a nav with a data-pagy attribute used by the pagy.js file
+    def pagy_combo_nav_js(pagy, id: nil, 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;">#{JSTools::A_TAG})
+
+      %(<nav#{id} class="pagy combo-nav-js" #{
+          nav_aria_label(pagy, aria_label:)} #{
+          pagy_data(pagy, :combo, pagy_url_for(pagy, PAGE_TOKEN, **vars))}>#{
+          prev_a(pagy, a)
+        }<label>#{
+          pagy_t('pagy.combo_nav_js', page_input:, pages:)
+        }</label>#{
+          next_a(pagy, a)
+        }</nav>)
+    end
+
+    # Return the previous page URL string or nil
+    def pagy_prev_url(pagy, **vars)
+      pagy_url_for(pagy, pagy.prev, **vars) if pagy.prev
+    end
+
+    # Return the next page URL string or nil
+    def pagy_next_url(pagy, **vars)
+      pagy_url_for(pagy, pagy.next, **vars) if pagy.next
+    end
+
+    # Return the enabled/disabled previous page anchor tag
+    def pagy_prev_a(pagy, text: pagy_t('pagy.prev'), aria_label: pagy_t('pagy.aria_label.prev'), **vars)
+      a = pagy_anchor(pagy, **vars)
+      prev_a(pagy, a, text:, aria_label:)
+    end
+
+    # Return the enabled/disabled next page anchor tag
+    def pagy_next_a(pagy, text: pagy_t('pagy.next'), aria_label: pagy_t('pagy.aria_label.next'), **vars)
+      a = pagy_anchor(pagy, **vars)
+      next_a(pagy, a, text:, aria_label:)
+    end
+
+    # Conditionally return the previous page link tag
+    def pagy_prev_link(pagy, **vars)
+      %(<link href="#{pagy_url_for(pagy, pagy.prev, **vars)}"/>) if pagy.prev
+    end
+
+    # Conditionally return the next page link tag
+    def pagy_next_link(pagy, **vars)
+      %(<link href="#{pagy_url_for(pagy, pagy.next, **vars)}"/>) if pagy.next
+    end
+  end
+  Frontend.prepend PagyExtra
+end

data/lib/pagy/extras/searchkick.rb

@@ -1,48 +1,59 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/searchkick
-# encoding: utf-8
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/searchkick
 # frozen_string_literal: true
 
-require 'pagy/extras/pagy_search'
-
-class Pagy
-
-  # used by the items extra
-  SEARCHKICK = true
-
-  # create a Pagy object from a Searchkick::Results object
-  def self.new_from_searchkick(results, vars={})
-    vars[:items] = results.options[:per_page]
-    vars[:page]  = results.options[:page]
-    vars[:count] = results.total_count
-    new(vars)
-  end
-
-  # Add specialized backend methods to paginate Searchkick::Results
-  module Backend ; private
-
-    # Return Pagy object and results
-    def pagy_searchkick(pagy_search_args, vars={})
-      model, search_args, block, *called = pagy_search_args
-      vars                       = pagy_searchkick_get_vars(nil, vars)
-      search_args[-1][:per_page] = vars[:items]
-      search_args[-1][:page]     = vars[:page]
-      results                    = model.search(*search_args, &block)
-      vars[:count]               = results.total_count
-      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_searchkick(pagy_search_args, vars.merge(page: pagy.page))
+class Pagy # :nodoc:
+  DEFAULT[:searchkick_search]      ||= :search
+  DEFAULT[:searchkick_pagy_search] ||= :pagy_search
+
+  # Paginate Searchkick::Results objects
+  module SearchkickExtra
+    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_searchkick(term = '*', **options, &block)
+        [self, term, options, block].tap do |args|
+          args.define_singleton_method(:method_missing) { |*a| args += a }
+        end
       end
-      return pagy, called.empty? ? results : results.send(*called)
+      alias_method Pagy::DEFAULT[:searchkick_pagy_search], :pagy_searchkick
     end
-
-    # Sub-method called only by #pagy_searchkick: here for easy customization of variables by overriding
-    # the _collection argument is not available when the method is called
-    def pagy_searchkick_get_vars(_collection, vars)
-      vars[:items] ||= VARS[:items]
-      vars[:page]  ||= (params[ vars[:page_param] || VARS[:page_param] ] || 1).to_i
-      vars
+    Pagy::Searchkick = ModelExtension
+
+    # Additions for the Pagy class
+    module PagyExtension
+      # Create a Pagy object from a Searchkick::Results object
+      def new_from_searchkick(results, **vars)
+        vars[:limit] = results.options[:per_page]
+        vars[:page]  = results.options[:page]
+        vars[:count] = results.total_count
+        new(**vars)
+      end
     end
-
+    Pagy.extend PagyExtension
+
+    # Add specialized backend methods to paginate Searchkick::Results
+    module BackendAddOn
+      private
+
+      # Return Pagy object and results
+      def pagy_searchkick(pagy_search_args, **vars)
+        vars[:page]  ||= pagy_get_page(vars)
+        vars[:limit] ||= pagy_get_limit(vars)
+        model, term, options, block, *called = pagy_search_args
+        options[:per_page] = vars[:limit]
+        options[:page]     = vars[:page]
+        results            = model.send(DEFAULT[:searchkick_search], term, **options, &block)
+        vars[:count]       = results.total_count
+
+        pagy = ::Pagy.new(**vars)
+        # with :last_page overflow we need to re-run the method in order to get the hits
+        return pagy_searchkick(pagy_search_args, **vars, page: pagy.page) \
+               if defined?(::Pagy::OverflowExtra) && pagy.overflow? && pagy.vars[:overflow] == :last_page
+
+        [pagy, called.empty? ? results : results.send(*called)]
+      end
+    end
+    Backend.prepend BackendAddOn
   end
 end

data/lib/pagy/extras/size.rb

@@ -0,0 +1,40 @@
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/size
+# frozen_string_literal: true
+
+class Pagy # :nodoc:
+  # Implement the legacy bar using the array size.
+  # Unless you have very specific requirements, use the faster and better looking default bar.
+  module SizeExtra
+    # Implements the old series algorithm
+    def series(size: @vars[:size], **_)
+      return super unless size.is_a?(Array)
+      return [] if size == []
+      raise VariableError.new(self, :size, 'to be an Array of 4 Integers or []', size) \
+            unless size.is_a?(Array) && size.size == 4 && size.all? { |num| !num.negative? rescue false } # rubocop:disable Style/RescueModifier
+
+      [].tap do |series|
+        # This algorithm is up to ~5x faster and ~2.3x lighter than the previous one (pagy < 4.3)
+        # However the behavior of the legacy nav bar was taken straight from WillPaginate and Kaminari:
+        # it's ill-concieved and complicates the experience of devs and users.
+        left_gap_start  = 1 + size[0]
+        left_gap_end    = @page - size[1] - 1
+        right_gap_start = @page + size[2] + 1
+        right_gap_end   = @last - size[3]
+        left_gap_end    = right_gap_end  if left_gap_end   > right_gap_end
+        right_gap_start = left_gap_start if left_gap_start > right_gap_start
+        start           = 1
+        if (left_gap_end - left_gap_start).positive?
+          series.push(*start...left_gap_start, :gap)
+          start = left_gap_end + 1
+        end
+        if (right_gap_end - right_gap_start).positive?
+          series.push(*start...right_gap_start, :gap)
+          start = right_gap_end + 1
+        end
+        series.push(*start..@last)
+        series[series.index(@page)] = @page.to_s
+      end
+    end
+  end
+  prepend SizeExtra
+end

data/lib/pagy/extras/standalone.rb

@@ -0,0 +1,60 @@
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/standalone
+# frozen_string_literal: true
+
+require 'uri'
+
+class Pagy # :nodoc:
+  # Use pagy without any request object, nor Rack environment/gem, nor any defined params method,
+  # even in the irb/rails console without any app or config.
+  module StandaloneExtra
+    # Extracted from Rack::Utils and reformatted for rubocop
+    # :nocov:
+    module QueryUtils
+      module_function
+
+      def build_nested_query(value, prefix = nil)
+        case value
+        when Array
+          value.map { |v| build_nested_query(v, "#{prefix}[]") }.join('&')
+        when Hash
+          value.map do |k, v|
+            build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+          end.delete_if(&:empty?).join('&')
+        when nil
+          escape(prefix)
+        else
+          raise ArgumentError, 'value must be a Hash' if prefix.nil?
+
+          "#{escape(prefix)}=#{escape(value)}"
+        end
+      end
+
+      def escape(str)
+        URI.encode_www_form_component(str)
+      end
+    end
+    # :nocov:
+
+    # Return the URL for the page. If there is no pagy.vars[:url]
+    # it works exactly as the regular #pagy_url_for, relying on the params method and Rack.
+    # If there is a defined pagy.vars[:url] variable it does not need the params method nor Rack.
+    def pagy_url_for(pagy, page, fragment: nil, **_)
+      return super unless pagy.vars[:url]
+
+      vars         = pagy.vars
+      params       = vars[:params].is_a?(Hash) ? vars[:params].clone : {}  # safe when it gets reused
+      pagy_set_query_params(page, vars, params)
+      params       = vars[:params].(params) if vars[:params].is_a?(Proc)
+      query_string = "?#{QueryUtils.build_nested_query(params)}"
+      "#{vars[:url]}#{query_string}#{fragment}"
+    end
+  end
+  UrlHelpers.prepend StandaloneExtra
+
+  # Define a dummy params method if it's not already defined in the including module
+  module Backend
+    def self.included(controller)
+      controller.define_method(:params) { {} } unless controller.method_defined?(:params)
+    end
+  end
+end

data/lib/pagy/extras/trim.rb

@@ -1,23 +1,29 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/trim
-# encoding: utf-8
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/trim
 # frozen_string_literal: true
 
-class Pagy
+class Pagy # :nodoc:
+  DEFAULT[:trim_extra] = true   # extra enabled by default
 
-  module Frontend
+  # Remove the page=1 param from the first page link
+  module TrimExtra
+    # Override the original pagy_anchor.
+    # Call the pagy_trim method for page 1 if the trim_extra is enabled
+    def pagy_anchor(pagy, **_)
+      a_proc = super
+      return a_proc unless pagy.vars[:trim_extra]
 
-    TRIM = true   # boolean used by *_js helpers
+      lambda do |page, text = pagy.label_for(page), **opts|
+        a = +a_proc.(page, text, **opts)
+        return a unless page.to_s == '1'
 
-    alias_method :pagy_link_proc_without_trim, :pagy_link_proc
-    def pagy_link_proc_with_trim(pagy, link_extra='')
-      link_proc = pagy_link_proc_without_trim(pagy, link_extra)
-      re = /[?&]#{pagy.vars[:page_param]}=1\b(?!&)|\b#{pagy.vars[:page_param]}=1&/
-      lambda do |n, text=n, extra=''|
-        link = link_proc.call(n, text, extra)
-        n == 1 ? link.sub(re, '') : link
+        pagy_trim(pagy, a) # in method for isolated testing
       end
     end
-    alias_method :pagy_link_proc, :pagy_link_proc_with_trim
 
+    # Remove the :page_param param from the first page anchor
+    def pagy_trim(pagy, a)
+      a.sub!(/[?&]#{pagy.vars[:page_param]}=1\b(?!&)|\b#{pagy.vars[:page_param]}=1&/, '')
+    end
   end
+  Frontend.prepend TrimExtra
 end

data/lib/pagy/frontend.rb

@@ -1,74 +1,99 @@
-# See Pagy::Frontend API documentation: https://ddnexus.github.io/pagy/api/frontend
-# encoding: utf-8
+# See Pagy::Frontend API documentation: https://ddnexus.github.io/pagy/docs/api/frontend
 # frozen_string_literal: true
 
-require 'yaml'
+require_relative 'i18n'
+require_relative 'url_helpers'
 
 class Pagy
+  # Used for search and replace, hardcoded also in the pagy.js file
+  PAGE_TOKEN  = '__pagy_page__'
+  LABEL_TOKEN = '__pagy_label__'
 
-  PAGE_PLACEHOLDER  = '__pagy_page__'  # string used for search and replace, hardcoded also in the pagy.js file
-
-  # I18n static hash loaded at startup, used as default alternative to the i18n gem.
-  # see https://ddnexus.github.io/pagy/api/frontend#i18n
-  I18n = eval(Pagy.root.join('locales', 'utils', 'i18n.rb').read) #rubocop:disable Security/Eval
+  # Frontend modules are specially optimized for performance.
+  # The resulting code may not look very elegant, but produces the best benchmarks
+  module Frontend
+    include UrlHelpers
 
-  module Helpers
-    # This works with all Rack-based frameworks (Sinatra, Padrino, Rails, ...)
-    def pagy_url_for(page, pagy, url=false)
-      p_vars = pagy.vars; params = request.GET.merge(p_vars[:params]); params[p_vars[:page_param].to_s] = page
-      "#{request.base_url if url}#{request.path}?#{Rack::Utils.build_nested_query(pagy_get_params(params))}#{p_vars[:anchor]}"
+    # Return a performance optimized lambda to generate the HTML anchor element (a tag)
+    # Benchmarked on a 20 link nav: it is ~22x faster and uses ~18x less memory than rails' link_to
+    def pagy_anchor(pagy, anchor_string: nil, **vars)
+      anchor_string &&= %( #{anchor_string})
+      left, right = %(<a#{anchor_string} href="#{pagy_url_for(pagy, PAGE_TOKEN, **vars)}").split(PAGE_TOKEN, 2)
+      # lambda used by all the helpers
+      lambda do |page, text = pagy.label_for(page), classes: nil, aria_label: nil|
+        classes    = %( class="#{classes}") if classes
+        aria_label = %( aria-label="#{aria_label}") if aria_label
+        %(#{left}#{page}#{right}#{classes}#{aria_label}>#{text}</a>)
+      end
     end
 
-    # Sub-method called only by #pagy_url_for: here for easy customization of params by overriding
-    def pagy_get_params(params) params end
-  end
-
-  # All the code here has been optimized for performance: it may not look very pretty
-  # (as most code dealing with many long strings), but its performance makes it very sexy! ;)
-  module Frontend
-
-    include Helpers
+    # Return examples: "Displaying items 41-60 of 324 in total" or "Displaying Products 41-60 of 324 in total"
+    def pagy_info(pagy, id: nil, item_name: nil)
+      id      = %( id="#{id}") if id
+      p_count = pagy.count
+      key     = if p_count.zero?
+                  'pagy.info.no_items'
+                elsif pagy.pages == 1
+                  'pagy.info.single_page'
+                else
+                  'pagy.info.multiple_pages'
+                end
 
-    EMPTY = ''               # EMPTY + 'string' is almost as fast as +'string' but is also 1.9 compatible
-    MARK  = PAGE_PLACEHOLDER # backward compatibility in case of helper-overriding in legacy apps
+      %(<span#{id} class="pagy info">#{
+          pagy_t key, item_name: item_name || pagy_t('pagy.item_name', count: p_count),
+                      count: p_count, from: pagy.from, to: pagy.to
+        }</span>)
+    end
 
     # Generic pagination: it returns the html with the series of links to the pages
-    def pagy_nav(pagy)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
+    def pagy_nav(pagy, id: nil, aria_label: nil, **vars)
+      id = %( id="#{id}") if id
+      a  = pagy_anchor(pagy, **vars)
 
-      html = EMPTY + (p_prev ? %(<span class="page prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</span> )
-                             : %(<span class="page prev disabled">#{pagy_t('pagy.nav.prev')}</span> ))
-      pagy.series.each do |item|  # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
-        html << if    item.is_a?(Integer); %(<span class="page">#{link.call item}</span> )               # page link
-                elsif item.is_a?(String) ; %(<span class="page active">#{item}</span> )                  # current page
-                elsif item == :gap       ; %(<span class="page gap">#{pagy_t('pagy.nav.gap')}</span> )   # page gap
+      html = %(<nav#{id} class="pagy nav" #{nav_aria_label(pagy, aria_label:)}>#{
+                 prev_a(pagy, a)})
+      pagy.series(**vars).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+        html << case item
+                when Integer
+                  a.(item)
+                when String
+                  %(<a role="link" aria-disabled="true" aria-current="page" class="current">#{pagy.label_for(item)}</a>)
+                when :gap
+                  %(<a role="link" aria-disabled="true" class="gap">#{pagy_t('pagy.gap')}</a>)
+                else
+                  raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
                 end
       end
-      html << (p_next ? %(<span class="page next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</span>)
-                      : %(<span class="page next disabled">#{pagy_t('pagy.nav.next')}</span>))
-      %(<nav class="pagy-nav pagination" role="navigation" aria-label="pager">#{html}</nav>)
+      html << %(#{next_a(pagy, a)}</nav>)
     end
 
-    # Return examples: "Displaying items 41-60 of 324 in total" of "Displaying Products 41-60 of 324 in total"
-    def pagy_info(pagy, item_name=nil)
-      path = if (count = pagy.count) == 0 ; 'pagy.info.no_items'
-             else pagy.pages == 1 ? 'pagy.info.single_page' : 'pagy.info.multiple_pages'
-             end
-      pagy_t(path, item_name: item_name || pagy_t(pagy.vars[:i18n_key], count: count), count: count, from: pagy.from, to: pagy.to)
+    # Similar to I18n.t: just ~18x faster using ~10x less memory
+    # (@pagy_locale explicitly initialized in order to avoid warning)
+    def pagy_t(key, **opts)
+      Pagy::I18n.translate(@pagy_locale ||= nil, key, **opts)
     end
 
-    # Returns a performance optimized proc to generate the HTML links
-    # Benchmarked on a 20 link nav: it is ~22x faster and uses ~18x less memory than rails' link_to
-    def pagy_link_proc(pagy, link_extra='')
-      p_prev, p_next = pagy.prev, pagy.next
-      a, b = %(<a href="#{pagy_url_for(PAGE_PLACEHOLDER, pagy)}" #{pagy.vars[:link_extra]} #{link_extra}).split(PAGE_PLACEHOLDER, 2)
-      lambda {|n, text=n, extra=''| "#{a}#{n}#{b}#{ if    n == p_prev ; ' rel="prev"'
-                                                    elsif n == p_next ; ' rel="next"'
-                                                    else                           '' end } #{extra}>#{text}</a>"}
+    private
+
+    def nav_aria_label(pagy, aria_label: nil)
+      aria_label ||= pagy_t('pagy.aria_label.nav', count: pagy.pages)
+      %(aria-label="#{aria_label}")
     end
 
-    # Similar to I18n.t: just ~18x faster using ~10x less memory
-    def pagy_t(path, vars={}) Pagy::I18n.t(@pagy_locale||=nil, path, vars) end
+    def prev_a(pagy, a, text: pagy_t('pagy.prev'), aria_label: pagy_t('pagy.aria_label.prev'))
+      if (p_prev = pagy.prev)
+        a.(p_prev, text, aria_label:)
+      else
+        %(<a role="link" aria-disabled="true" aria-label="#{aria_label}">#{text}</a>)
+      end
+    end
 
+    def next_a(pagy, a, text: pagy_t('pagy.next'), aria_label: pagy_t('pagy.aria_label.next'))
+      if (p_next = pagy.next)
+        a.(p_next, text, aria_label:)
+      else
+        %(<a role="link" aria-disabled="true" aria-label="#{aria_label}">#{text}</a>)
+      end
+    end
   end
 end